Discussions au sujet de NI LabVIEW
comment savoir si un nombre est paire ou impaire ?
Résolu !
il faut "tester" le bit de poids faible ... le bit 0.
Tout les nombres paires ont le bit 0 = 0 ... tous les nombres impaires ont le bit 0 = 1
voici deux méthodes "vite fait" ... il y en a probablement d'autres.
ci-joint le VI en LabVIEW 2012
super ! 
c'est peut-être "l'occasion" de t'intéresser d'avantage à la représentation binaire des nombres et aux portes logiques.
(et pour moi d'écrire "nombre pair" sans "e") 
bon code Gilles.
@Gilles : "... je trouve cela très surprenant et j'avoue ne pas bien comprendre ce qu'il fait"
Le binaire n'a pas d'existence par lui même (ce n'est pas "un fond", mais "une forme") ... c'est juste une façon de représenter un nombre.
Pour représenter un nombre, on a besoin "d'une base". Communément, nous utilisons la base 10. (représentation décimale)
Mais on peut utiliser n'importe quelle base. La représentation binaire (ou binaire) utilise la base 2
Les ordinateurs ne peuvent utiliser que le binaire pour représenter un nombre.
Pourquoi ? Parce qu'il ne savent "matérialiser" que 2 états ... "tension" et "pas tension"
Un fil est soit parcouru par un courant, soit il ne l'est pas.
exemple : le nombre 117
en base 10, le nombre 117 s'écrit 117 ... soit ... (7x10^0)+(1x10^1)+(1x10^2) = 7+10+100 = 117
en base 2, le nombre 117 s'écrit 1110101 ... soit ... (1x2^0)+(0x2^1)+(1x2^2)+(0x2^3)+(1x2^4)+(1x2^5)+(1x2^6) = 1+0+4+0+16+32+64 = 117
Revenons à ce que tu as fait ... une porte ET (porte AND) avec sur une de ses entrées le terminal d'itération de ta While, et sur l'autre entrée le nombre "1".
Que se passe-t-il ?
Le terminal d'itération va successivement donner à sa sortie les nombres suivants : 0 , 1 , 2 , 3, etc .... (soit en binaire, sur 4 bits, 0000, 0001, 0010, 0011, etc)
Nous aurons donc ceci : (utilisons pour l'exemple uniquement les 4 premiers bits)
1) 0000 AND 0001 = 0000
2) 0001 AND 0001 = 0001
3) 0010 AND 0001 = 0000
4) 0011 AND 0001 = 0001
Une opération logique se fait "bit à bit" (le bit 0 avec le bit 0, le bit 1 avec le bit 1, ... etc)
Tu as donc effectivement, en sortie de ta porte AND, une séquence de "0" et de "1".
voici la "Table de Vérité" d'une porte AND (c'est comme ça que l'on nomme la représentation du comportement d'une porte logique)
A B C
0 0 = 0
0 1 = 0
1 0 = 0
1 1 = 1
A(entrée A) , B(entrée B) , C(sorie)
Tu remarqueras que l'une des entrées agit sur l'autre comme un "masque".
Je m'explique, prenons comme masque l'entrée "A".
Si A=0, quelque soit la valeur de B, la sortie C=0 .... et si A=1, alors B "passe", et la sortie C prend la valeur de B.
En utilisant le nombre 1 à une des entrées de ta porte AND, tu as utilisé le nombre 1 comme "masque" (0001 sur 4 bits)
et donc, seul le bit 0 de ton terminal d'itération "passera".
Quand la sortie du terminal d'itération est paire, son bit 0 = 0 ..... la sortie de ta porte AND sera égale à 0
Quand la sortie du terminal d'itération est impaire, sont bit 0 = 1 ..... la sortie de ta porte AND sera égale à 1
Tout ceci est parfaitement cohérent ... tu as donc bien une suite de 0 et de 1 en sortie de ta porte AND
voilou 
Cela dit, quand le nombre est codé sur 4 bits ou plus, LV ne prend QUE le premier bit (celui de poids faible) pour opérer la comparaison ?
Non, LV prend TOUS les bits ... par exemple un U32, c'est 32 bits. (4 bits, c'était juste pour l'exemple, pour ne pas m'encombrer avec des représentation sur 32 bits)
1 sur 32 bits = 00000000000000000000000000000001
5 sur 32 bits = 00000000000000000000000000000101
1 AND 5 == 00000000000000000000000000000001 AND 00000000000000000000000000000101
Le AND se fait "bit à bit" ... les bits rouges ensemble ... les bits verts ensemble ... les bits bleus ensemble ... etc
En fait, c'est 32 fonctions AND entre chaque bits 0 (rouge), entre chaque bit 1 (vert), chaque bit 2 (bleu) ... etc.
LabVIEW propose plusieurs "format" (U8 8bits, U16 16bits, U32 32 bits ... et encore d'autres)
La sortie du terminal d'itération d'une While est un I32 ... c'est à dire un nombre sur 32bits, mais signé ...
Un U32 ne peut représenter que des nombres positifs, alors qu'un I32 peut représenter un nombre positif ET négatif.
@Gilles : subtile tout ça... Naannn ... facile .... il faut t'y "mettre" ... bienvenue dans le monde de la Logique.
Tu aurais pu également utiliser la définition d'un nombre pair.
à savoir : un nombre est pair si il est un multiple de 2
et son corollaire immédiat : la division d'un nombre pair par 2 donne un reste nul.
Ce qui donne ceci :
