# Environnements de dveloppement > Delphi > Codes sources  tlcharger >  Comment dterminer la parit d'un nombre

## DelphiCool

Bonjour, 

Je vous propose un nouvel lment  utiliser : Comment dterminer la parit d'un nombre

Comment dterminer la parit d'un nombre.

Qu'en pensez-vous ?

----------


## Dr.Who

pour des entiers il est plus simple et performant de faire :



```

```

car en binaire seul le premier bit est gal  1 donc impair, donc si ce bit est  zro, le chiffre est paire.
tout cela se passe par un masque ET sur bit 0x01

Ta mthode :



```

```

gnre l'assembleur suivant :



```

```


*soit 9 instruction,* deux conditions jump, une addition, une comparaison, un ou exclusif, un dcalage de bit  .... tout a pour ... savoir si N est pair ou impair.

mme en optimisant :



```

```

on gnre en assembleur :



```

```


-2 instructions... pourtant on a supprimer pas mal de trucs.

Donc non, la mthode est " connaitre" mais  ne pas mettre en production.

voici l'assembleur gnr par le "ET 1" :



```
result := (votreChiffre and 1) = 0;
```



```

```


deux instructions.

----------


## Gilbert Geyer

Bonjour,

Et avec if not odd(MonEntier) then MonEntierEstPair n'est ce pas kif-kif ?

A+.  ::D:

----------


## Dr.Who

```
not odd(N)
```

gnre sur D2009 ceci :



```

```


mais (N and 1) xor 1 n'est pas une expression boolenne ! 
pour la rendre boolenne il faudrait l'ecrire :

boolean((N and 1) xor 1)

Ce qui oblige a faire un transtypage, qui ne change rien  l'assembleur gnr, certes, mais qui fait de l'criture en plus pour le dveloppeur.

par contre je crois que sur les anciennes version de delphi Odd etait une fonction donc risque de donner 4 instruction voir 5 au lieu de 2.

autre avantage, c'est que Odd n'est pas forcement dispo sur tout les langages (php, javascript par exemple),  la solution AND= fonctionne donc sur tous :

php : ($N & 1 == 0)
javascript/c/perl : (N & 1 == 0)
python : (N and 1 == 0)
delphi : ((N and 1) = 0)
asm : test al,$1; setz al;

facile  retenir et  implmenter.

la solution du XOR peut par contre tre pratique pour faire de la condition un slecteur d'index dans un tableau ou liste. puisque le resultat par dfaut est un entier.


```

```

----------


## Gilbert Geyer

Bonjour,

A Dr Who : 


> Odd fonction [de Delphi1 et au moins jussqu' D5] ... risque de donner 4 instructions voir 5 au lieu de 2.


 ::ccool:: 

Ok, merci, ... mais qu'est-ce-que c'est bien compliqu quand on n'y pige rien en Asm. ::mouarf:: 

A+.  ::D:

----------


## Dr.Who

Oh non, je disais a aussi au dpart, mais en fait c'est trs trs simple.

faut juste s'y mettre un peu.  ::D: 

Du moins tant qu'on comprend que, plus il y a d'instructions plus a mets du temps et donc, moins il y en as, moins a mets de temps, c'est dj a.

par exemple, si tu fait inc(I), tu obtient une seule instructions. 

Et les instructions de ce type, sur un registre 32bit, tu peux considrer que tu peux en 1 seconde en faire autant que de Ghz du CPU ( quelques milliers prs).

en gros, CPU 1.8Ghz -> 1 seconde = 1 800 millions d'incrmentations possible (thorique), CPU 3Ghz -> 1 seconde = 3 milliard d'incrmentations possible.

exemple 



```

```

thoriquement, il faut 1 seconde pour excuter cette boucle hors instructions ncessaires  la boucle (1 seconde galement).
soit  peu prs entre 1 et 3 secondes maximum.

Les oprations sur les flottant (hors type Single) sont quasiment le double ou quadruple de temps.
Single est trs rapide car 32bits, ce n'est pas pour rien qu'il est prfr  Double dans la GDI+, OpenGL et DirectX.

----------


## Gilbert Geyer

Bonjour,

A *Dr Who* : 


> Du moins tant qu'on comprend que, plus il y a d'instructions plus a mets du temps et donc, moins il y en as, moins a met de temps, c'est dj a


.
OK, a c'est clair comme de l'eau de roche.




> Single est trs rapide car 32bits, ce n'est pas pour rien qu'il est prfr  Double dans la GDI+, OpenGL et DirectX.


C'est bon  savoir, car on hsite souvent lors du choix entre les divers types de Flottants.

A+.  ::D:

----------


## Caribensila

@Gilbert

Dans le mme ordre d'ide, un _pf32bit_ s'affiche plus de deux fois plus vite qu'un _pf24bit_ sur un systme 32 bits.
Pour toi qui fait fort dans le graphisme en ce moment, c'est bon  savoir.

----------


## Gilbert Geyer

Bonjour,

A *Caribensila* :


> Dans le mme ordre d'ide, un pf32bit s'affiche plus de deux fois plus vite qu'un pf24bit sur un systme 32 bits.
> Pour toi qui fait fort dans le graphisme en ce moment, c'est bon  savoir.


Super, merci pour l'info a me permettra de faire un nettoyage dans mes units
(J'utilise Delphi-5, 32 bits sous Windows 64bits).

A+.  ::D:

----------


## Teddy

Merci Dr.Who, on s'amliore tous les jours grce  des gens comme vous !

----------


## Dr.Who

cari  parfaitement raison, un bitmap 32bits se gre deux fois plus rapidement qu'un bitmap 24 bits.

car 1 pixel = 1 registre = 4 octet = base d'allocation mmoire.

Si j'alloue la mmoire de 4 en 4 (ou de 2 en 2) je tomberai pile sur la taille d'une page de mmoire.

bitmap 1024*768*32bits = 768 pages 
bitmap 1920*1080*32bits = 2025 pages
parcours des pixels avec les registres types EAX, EDX, ECX

bitmap 1024*768*24bits = 576 pages <- a vas encore
bitmap 1920*1080*24bits = 1518.75 pages ! <- et voila le caca.
parcours des pixels avec les registres type ESI/EDI

Attention, avec PNG, PNG24 n'est pas purement 24Bit ! C'est un bitmap 32bit dont le 4eme octet est utilis pour l'alpha.
donc PNG24 = BMP32.

est inutile de faire :



```

```

Par contre, JPEG est 24bit et = BMP24.

Donc est ncessaire de faire :



```

```

----------

