Discussion :

[gaspar.koenig]

Bonsoir.

J'ai un problème sur un programme lorsque que je rentre, pour une variable particulière du code qui ne change pas au cours de son déroulement, une valeur à virgule (le problème ne se pose plus lorsque la valeur est entière)...

En effet lorsque je rentre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ma_variable=600.04;

et que (même en stoppant le programme juste derrière) je tape dans la console...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

num2str(Ma_variable,17)

... ce qui me permet d'afficher toute la valeur...

... j'obtiens 600.0400000000000001

Ainsi ma variable est systématiquement faussée de ce pouillème qui sort dont ne sait où...

Cela m'était déjà arrivé avec l'édition d'un vecteur et j'avais corrigé le problème avec "roundn" mais le problème avait fini par disparaitre.
Mais cette fois même "roundn" n'a aucun effet et mon code ne marche plus du tout avec une grandeur à virgule alors qu'il le faisait avant (la variable est tout au début)...

Quelqu'un saurait ce qui se passe?
J'ai utilisé les fonctions isinteger et ~isinteger à un moment dans le code (après la déclaration) mais j'ai fini par les enlever... Il me semble que pour la première apparition du problème, c'était aussi à la suite de cela...

[Jerome Briot]

MATLAB ne "débloque" pas du tout.

voir la FAQ : Pourquoi 0.3-0.2-0.1 est-il différent de 0 ?

[gaspar.koenig]

Merci pour vote réponse.

Après avoir lue la FAQ, je ne comprends toujours pas pourquoi "Ma_variable" n'est pas égale à la valeur que je lui rentre (il ne s'agit pas d'un vecteur pour moi pour moi dans le cas présent)... Ni pourquoi la fonction "roundn" ne fonctionne pas dessus...

[Jerome Briot]

Les nombres réels ne peuvent pas tous être représenté avec une précision parfaite avec MATLAB car ce dernier se conforme à la norme IEEE 754.

J'avais tenté une explication simplifiée ici : Probleme de mantisse nombre flottant

Pour une explication plus précise : Cleve Moler on Mathematics and Computing - Floating Point Numbers et pour aller encore plus loin dans la norme : Floating Point Denormals, Insignificant But Controversial

[gaspar.koenig]

Merci pour ces informations. Je vais prendre le temps de les lire...

Si je comprends bien déjà, le problème vient du nombre choisi qui ne peut être représenté en valeur exacte, mais d'autres valeurs marcheraient sans problème c'est bien ça (sauf si elle correspondent au même cas)?

Avez vous une solution standard pour détecter ce problème et le corriger lors des opérations effectuées dessus? Ou bien est-ce que le problème se répercutera quoi qu'il arrive si l'on part d'une valeur qui ne peut être représentée en un nombre de bits fini?

[Jerome Briot]

Tu dois prendre en compte cette imprécision dans ton code.

Montre nous la ligne où cela pose problème dans ton code.

[gaspar.koenig]

Merci beaucoup pour votre intérêt...

Je veux créer deux fonctions qui ne sont pas forcément de la même taille, toutes deux définies centrées autour de zero avec le même pas réglable.

Je veux ensuite les comparer point par point (ou comparer leur dérivée et d'autres caractéristiques) et il faut donc que je prolonge la plus petite. Je veux aussi garder en mémoire l'indice du point de liaison avec le prolongement pour l'identifier plus tard... C'est quand je fais appel aux indices de ces points que j'ai mon erreur, mais j'ai déjà des alertes avant avec des fonctions comme zeros ou ones...

EDIT: Je ne sais pas si il va être très utile de lire le code avant d'avoir lu ce qui le suit...

J'ai ajouter au code quelques commentaires et j'ai mis en gras les premiers endroits où mon erreur se produit... (ce code n'est peut être pas le mien avec exactitude car je n'ai pas l'original sous les yeux actuellement mais je pense qu'il devrait "fonctionner" avec les valeurs employées, même incomplet).

Alors...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
%%%%%% Variables de base %%%%%%

Pas=0.01;
Taille_f1=110.04; % La fonction num2str(Taille_f2,17) me donne Taille_f2==110.04000000000001 et non 110.04
Taille_f2=110; 

%%%%%% Définition de f1 et de sa dérivée %%%%%%

Xpos_f1=0:pas:Taille_f1/2;
Xneg_f1=0:-pas:-Taille_f1/2;
Xtot_f1=[Xneg_f1(end:-1:2) Xpos_f1];

Ypos_f1=Xpos_f1.^2;
Yneg_f1=Xneg_f1.^2;
Ytot_f1=[Yneg_f1(end:-1:2) Ypos_f1];

derYpos_f1=2*Xpos_f1;
derYneg_f1=2*Xneg_f1;
derYtot_f1=[derYneg_f1(end:-1:2) derYpos_f1];

%%%%%% Définition de f2 et de sa dérivée %%%%%%

Xpos_f2=0:pas:Taille_f2/2; % Bien entendu mon erreur se propage dans X_f2 mais cela ne m'a pas encore gêné...
Xneg_f2=0:-pas:-Taille_f2/2; 
Xtot_f2=[Xneg_f2(end:-1:2) Xpos_f2];

Ypos_f2=Xpos_f2.^2;
Ypos_f2=Xpos_f2.^2;
Ytot_f2=[Yneg_f2(end:-1:2) Ypos_f2];

derYpos_f2=2*Xpos_f2;
derYneg_f2=2*Xneg_f2;
derYtot_f2=[derYneg_f2(end:-1:2) derYpos_f2];

%%%%%% Déclaration des erreurs %%%%%%%%

if Taille_f1/(2*pas)~=fix(Taille_f1/(2*pas)); error('message'); end                      %erreur si la moitiée de la taille de définition de f1 n'est pas un multiple du pas.
if Taille_f2/(2*pas)~=fix(Taille_f2/(2*pas)); error('message'); end                      %erreur si la moitiée de la taille de définition de f1 n'est pas un multiple du pas.
if abs(Taille_f1-Taille_f2)/(2*pas)~=fix(abs(Taille_f1-Taille_f2)/(2*pas)); error('message'); end %si leur différence (aux moitiées) n'est pas multiple du pas.

%Il y avait déjà une erreur à cette dernière ligne pour la raison évoquée dans les message précédents mais je l'ai corrigé en remplaçant "fix" par une fonction 
%"roundouf" qui arrondit une valeur d'entrée avec un pas souhaité (par exemple 0.125 ou autre... et on peut rajouter un "offset"... Si le pas est l'unité et que l'on 
%veut arrondir un 6.5 par exemple, l'onrrondi sera à 7, mais -6.5 sera arrondi à -7)... Elle corrige aussi les erreurs suivantes... Je peux vous la montrer si cela vous 
%intéresse mais c'est basique...

%%%%%% Prolongement de la fonction la plus courte %%%%%% Il existe des options pour faire cela de différentes façons mais peu importe ici...

if T1>T2; %Si T1>T2 on prolonge les X et les Y de f2 simplement par concaténation de nouveaux intervalles dans de nouveaux vecteurs avec d'autres noms...

    ecart_T=T1-T2; INDprolzero=length(Xpos_f2); INDprolext=ecart_T/(2*pas); % erreur sur ecart_T (mon problème), c'est la que tout commence!!!

    rac1X=T2/2:pas:T1/2;                                        rac2X=-T2/2:-pas:-T1/2;
    X2pos_f2=[Xpos_f2 rac1X(2:end)];                       X2neg_f2=[Xneg_f2 rac2X(2:end)];
    Y2pos_f2=[Ypos_f2 zeros(1,ecart_T/(2*pas))-1];    Y2neg_f2=[Yneg_f2 zeros(1,ecart_T/(2*pas))-1]; %écart_T/(2*pas) devrait être entier, ne l'est pas, mais
    X2tot_f2=[X2neg_f2(end:-1:2) X2pos_f2];              Y2tot_f2=[Y2neg_f2(end:-1:2) X2pos_f2];           %Matlab comprend tout de même ce que je veux...
    derY2tot_f2=[zeros(1,ecart_T/(2*pas)-1) derYpos_f2 zeros(1,ecart_T/(2*pas)-1)];                           % ici aussi...

    X2pos_f1=Xpos_f1; X2neg_f1=Xneg_f1; Y2pos_f1=Ypos_f1; %etc... Toutes les nouvelles variables relatives à f1 sont égales aux anciennes.

elseif T1<T2; % Vice versa 
else             % Si T1==T2 alors les nouvelles variables rélatives et à f1 et à f2 sont égales aux anciennes...
end

%etc... reste du code... des trucs du genre...

Xneg_ptrac_f2=X2tot_f2(ecart_T/(2*pas));

Mon erreur se produit ensuite quand je cherche à accéder aux indices des points de raccordement, comme à la fin du code ci-dessus, (que ce soit celui de l'espace positif ou négatif) dans mes vecteurs complets car c'est ceux la que je veux comparer.
Pour ces valeurs de T1 et T2 il m'envoie un message du genre.

Matlab try to access X2tot_f2(4). Index must be a positive integer value or logical.

J'ai vraiment du mal à comprendre comment un programme comme Matlab n'arrive pas à se soustraire à cette impricision du calcul. D'ailleurs il semble justement en être capable puisque qu'il le fait avec la fonction zeros quand je prolonge mes vecteurs relatifs à f2 ainsi que quand le message d'erreur indique qu'il comprend quel élément du vecteur je cherche.

EDIT: si le problème vient du calcul par le procésseur comment se fait il que...

De plus, avec ma fonction "roundouf" mensionnée dans les commentaires du code j'arrive à obtenir la valeur exacte à chaque fois que je l'ajoute dans un calcul où cela est nécéssaire, donc je suis vraiment surpris qu'il n'arrive pas à stoquer cette valeur exacte et par exemple, dans la ligne de mon code relative à l'erreur déclenchée si la différence de taille des deux fonction n'est pas un multiple du double du pas, l'erreur se produisait avec la fonction fix mais plus avec roundouf alors qu'au niveau calculatoire elle donnent toutes deux la même chose (pour ce pas de calcul "unitaire" en tout cas).

Je n'ai pas encore pû me plonger plus avant dans la "correction" de mon programme et ce problème est clairement très... ennuyeux, ça va être lourdingue, mais je pense pouvoir m'en sortir sans aide. J'aimerais vraiment avoir des suggestions tout de même et je vais laisser cette discution ouverte quelques jours au cas où je tomberais sur des couacs......

D'ailleurs je m'excuse pour les deux autres discutions que j'ai ouvertes si elles n'ont pas été fermées, les problèmes qu'elles soulèvent sont mis en parenthèse en ce moment et je dois revenir dessus prochainement, de plus j'ai actuellement des difficultées à accéder à internet.

J'ai aussi une autre question que je ne sais pas où poser : Puis-je changer de mot de passe et si oui comment? où cliquer?

[gaspar.koenig]

Bonjour.

Voici mon premier couac...

Je détermine mon vecteur de fonction ainsi... avec l'aide la fonction "arrondouf" que j'ai créée et que je poste en premier...

fonction arrondouf :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
function grdrfin=arrondouf(grdr,pas,offset)
 
if 1/pas~=fix(1/pas); error('1 doit être un multiple du pas d''arrondi.'); end
 
quotient=fix(grdr/abs(pas));
surplus=grdr-quotient*abs(pas);
 
if abs(surplus)>=abs(pas)/2; grdr=quotient*abs(pas)+sign(grdr)*pas;
else grdr=quotient*abs(pas);
end
 
grdrfin=grdr+offset;

mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
taille=110.04;
pas=0.01;
 
Xpos=0:pas:arrondouf(taille,pas,0);
Xneg=0:-pas:arrondouf(-taille,pas,0);
Xtot=arrondouf([Xneg(end:-1:2) Xpos],pas,0);
 
Ypos=(arrondouf(Xpos,pas,0)).^2;
Yneg=(arrondouf(Xneg,pas,0)).^2;
Ytot=[Yneg(end:-1:2) Ypos];

Ensuite, dans mon code je passe par la fonction diff des deux demi Y et leur atan pour trouver la dérivée. Je trace le tout ainsi...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
diffYpos=diff(Ypos);
diffYneg=diff(Yneg);
TDAYpos=diffYpos/pas;
TDAYneg=diffYneg/-pas;
derYtot=[TDAYneg(end:-1:1) 0 TDAYpos];
figure(1);
plot(Xtot,Ytot,'b',Xtot,derYtot,'g',Xtot,derYtot*180/pi,'g');

Je trace aussi ma fonction dans une seconde fenêtre avec ses perpendiculaires en chaque valeur unitaire...

Voilà ce que j'obtiens dans mon code original lorsque je garde une valeur entière pour T1...




Mais voici ce que j'obtiens après modification de mon code comme ci-dessus... Il semble que la fonction soit bien calculée (je la trace avec 'b.' pour la voir mieux) mais il semble que le reste soit perturbé... Je passe simplement par :




On voit clairement un problème sur le calcul de la dérivée (qui semble être "séquentiel" d'ailleurs) :

Edit : Il s'agit d'un zoom... On dirait que le problème se produit systématiquement sur deux points d'affilée.
Sur l'image suivante on voit que la dérivée verte (passant par la fonction diff) suit la dérivée rouge (calcul direct de la dérivée) au point x=-0,28 est est donc bonne, mais au point x=-0,29 elle vaut 0 et au point -0,30 elle vaut le double de ce qu'elle devrait, puis elle reprend son court normal...



Quelqu'un aurait une piste pour corriger mon problème???

[gaspar.koenig]

Bonjour.

Le problème semble bien venir de ma fonction arrondouf. En effet j'ai l'impression qu'avec l'imprécision de la norme IEEE, certaines valeurs ne sont pas arrondies correctement à cause de l'utilisation de "fix" dans ma fonction.

Voici ma fonction arrondouf qui tente d'arrondir toute grandeur entrée en premier argument au pas, entré en deuxième, et lui applique ensuite un offset, troisième argument de la fonction...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
function grdrfin=arrondouf(grdr,pas,offset)
 
if 1/pas~=fix(1/pas); error('1 doit être un multiple du pas d''arrondi.'); end
 
quotient=fix(grdr/abs(pas));
surplus=grdr-quotient*abs(pas);
 
if abs(surplus)>=abs(pas)/2; grdr=quotient*abs(pas)+sign(grdr)*pas;
else grdr=quotient*abs(pas);
end
 
grdrfin=grdr+offset;

Pourriez vous m'aider à en faire une fonction générale?... avec un pas de 2 par exemple (supérieur à l'unité), ce qui ne marche pas présentement...

J'avais aussi pensé utiliser un code du genre qui suit pour détecter le nombre de chiffres de mes valeurs mais je ne m'en sors pas, je ne sais pas comment faire...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
boucle=0;
if pas>1;
         while pas>1;
                 pas=pas/10;
                 boucle=boucle+1;
         end
elseif pas<1;
        while pas<1;
               pas=pas*10;
               boucle=boucle-1;
       end
end

EDIT :

Là, je ne comprends plus rien de ce que MATLAB est en mesure de calculer...

J'ai modifié mon code arrondouf de manière à mieux comprendre ce qu'il ce passe... Il y a désormais un affichage de certaine grandeurs critiques dans la console.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function grdrfin=arrondouf(grdr,pas,offset)
 
quotient=fix(grdr/abs(pas));
surplus=grdr-quotient*abs(pas);
 
boucle=0;
surplusprim=surplus;
if surplusprim<10 && surplusprim>=1;
elseif surplusprim>10; while surplusprim>10; surplusprim=surplusprim/10; boucle=boucle+1; end
elseif surplusprim<1; while surplusprim~=fix(surplusprim); surplusprim=surplusprim*10; boucle=boucle-1; end
end
 
['boucle ' num2str(boucle,3)]
['quotient ' num2str(quotient,20)]
['surplus ' num2str(surplus,20)]
['surplusprim ' num2str(surplusprim,20)]
['R(surplus) ' num2str(roundn(surplus,log10(10^boucle)))]
['(pas/2) ' num2str(pas/2,20)]
['R(pas/2) ' num2str(roundn(pas/2,log10(10^(boucle-sign(boucle)))),20)]
 
if abs(roundn(surplus,log10(10^boucle)))>=roundn(laylaylay,log10(10^boucle)); grdr=quotient*abs(pas)+sign(grdr)*abs(pas);
else grdr=quotient*abs(pas);
end
 
grdrfin=grdr+offset;

Je l'utilise avec un fichier test tel que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
clear all;
close all;
 
grgr=110.00625;
pas=0.0125;
 
grdr=arrondouf(grgr,pas,0)

Le résultat me donne grdr=110 au lieu de 110,0125... Le problème a lieu dans arrondouf quand je test si roundn(surplus)>=roundn(abs(pas)/2) au tout début du 2ème if.
Matlab arrive à calculer que roundn(surplus)=0,00625 mais n'arrive pas à calculer que roundn(abs(pas)/2) a la même valeur...

Je ne comprends pas...

[gaspar.koenig]

Problème quasiment résolu...