Interrogation sur comment marche le décompte d'une boucle FOR

[Azraael]

Bonjour,

J'ai créé un mini programme ayant pour but d'afficher des valeurs dans un tableau. Par exemple, l'utilisateur rentre un minimum, un maximum ainsi qu'un pas et le tableau retourne les valeurs demandées.

J'aimerais que quelque soit les valeurs rentrées par l’utilisateur, le min et le max s'affiche dans le tableau même si le pas ne permet pas d'afficher la valeur max. Je m'explique : l'utilisateur rentre :

- Imin = 0, Pas = 0.2, Imax = 1, le programme renvoi : 0  0.2  0.4  0.6  0.8  1

- Imin = 0, Pas = 2, Imax = 7, le programme renvoi : 0  2  4  6  7

En testant mon programme, je me suis aperçue que pour certaines valeurs, cela marchait mais que pour d'autres, cela ne fonctionnait pas. Je suis donc rentrée dans des calculs mathématique (simple!) pour essayer de comprendre si LabVIEW utilisé un arrondi mais d’après ce que j'ai observé, cela ne me permet pas de comprendre. Je m'explique : j'ai par exemple rentré :

- Imin = 0, Pas = 3, Imax = 7, mon calcul initialisant la boucle donne [(7-0)/3]+1 = 3.33 et j'obtiens 0  3  6 (au lieu de 0  3  6  7)

- Imin = 0, Pas = 3, Imax = 8, mon calcul initialisant la boucle donne [(8-0)/3]+1 = 3.667 et j'obtiens 0  3  6  8 (ce que j'attends)

Je me suis donc dit que LabVIEW arrondissait au dessus de 0.5, sauf qu'en essayant de vérifier cela j'ai refait un test :

- Imin = 0, Pas = 2, Imax = 5, mon calcul initialisant la boucle donne [(5-0)/2]+1 = 3.5 et j'obtiens 0  2  4  5 (ce que j'attends) MAIS

- Imin = 0, Pas = 2, Imax = 7, mon calcul initialisant la boucle donne [(7-0)/2]+1 = 4.5 et j'obtiens 0  2  4  6 (au lieu de 0  2  4  6  7)

Quelqu'un peut-il m'aider à comprendre comment résoudre mon soucis? Je n'ai peut-être pas cherché au bon endroit mais je suis à court d'idée. J'ai joint mon petit programme en pièce jointe.

[ben64]

Utilise la fonction Round Toward +Infinity avant de cabler l'index N de la boucle FOR.

Ben64

[ben64 · Accepted solution]

L'indice d'une boucle for est un entier, utilise la fonction "Round Toward +Infinity" avant de cabler l'index de la boucle FOR.

Ben64

[ML927 · Accepted solution]

En effet, pense à arrondir à l'entier supérieur à chaque fois. Pourquoi ?

A cause de ça : http://www.ni.com/white-paper/7612/en/ !

Dans ton cas :

• 3,5 est sûrement égal à 3,499999999 et des bananes. LabVIEW va arrondir à 3.
• 4,5 est sûrement égal à 4,500000000 et des brouettes (de bananes éventuellement). LabVIEW va arrondir à 5.

Donc oui, il faut arrondir dans une direction donnée pour être sûr du résultat 😉

[ben64]

En fait c'est plus mystérieux car 3.5 et 4.5 ont des représentations binaires exactes (3.50000000000000000..., 4.50000000000000...) mais dans un cas comme dans l'autre lorsqu'on relie ces valeurs dbl à l'indice N de la boucle FOR on obtient N=4.

Si on regarde les représentations binaires de 3.5, 4.0 et 4.5 (signe_exposant_mantisse) on a:

3.5->  0 10000000 11000000000000000000000

4.0->  0 10000001 00000000000000000000000

4.5->  0 10000001 00100000000000000000000

alors j'ai l'impression que LabVIEW arrondi la mantisse à la plus proche puissance de 2 ce qui donnerait 4 dans les 3 cas (10000001), mais ce n'est qu'une supposition.

En règle générale, lorsque qu'il s'agit de nombre double mieux vaut ne pas laisser la conversion au hasard!

 note, pour 3.5 la mantisse = 1.75, pour 4 c'est 0 et pour 4.5 elle est égale à 1.125

EDIT: Ça ne semble pas être ça sinon 9.5 serait arrondi à 8.

Ben64

[ML927]

Un topic à relire sur la question 🙂

[ben64]

Merci pour le lien. Je crois avoir trouvé la règle utilisée pour la conversion de dbl à I32. On regarde le dernier bit égal à 1 de la mantisse, si le bit précédent est 0 alors on le change pour 0 (01 -> 00) et s'il est 1 alors on ajoute 1 à ce bit (011->100, 0111->1000,...).  Voici deux examples: (3.5->4.0 et 4.5->4.0)

 

[ouadji]

Une intéressante discussion ...

J'ai ouvert le code, juste une petite chose (au delà de ce problème d'arrondi) Pourquoi utiliser des locales alors que les terminaux sont facilement disponibles ? Toujours utiliser les Terminaux quand cela est possible, les locales c'est quand il n'y a pas moyen de faire autrement ... mais les cas sont rares. Comme ceci :

Mes excuses d'avoir interrompu votre échange ... je ferme la porte 

[Azraael]

Un énorme merci, d'une pour la solution (effectivement je n'ai pas du tout pensé à câbler cette fonction) mais aussi pour vous êtes creusé la tête pour comprendre d’où venez mon problème! Après mes calculs je ne comprenais vraiment pas comment LabVIEW gérait la chose... et je n'ai pas du tout pensé à passer en binaire! Comme on dit, c'est en forgeant qu'on devient forgeron mais il me reste encore beaucoup de chemin, encore merci à vous!

Merci ouadji pour la remarque également, effectivement, mes variables non pas grand chose à faire ici mais c'est en faite un bout de code que j'ai refait vite fais et que j'ai adapté et j'ai recodé pareil sans trop réfléchir, j'étais trop concentrée sur mon problème ^^

[ben64]

On peut éviter une telle situation en utlisant une boucle while et la fonction In Range & Coerce pour générer le tableau voulu.

Ben64