Algorithme d\'échange de XOR

Dans la programmation par ordinateur , l'échange du XOR est un algorithme qui emploie l'opération du XOR au niveau du bit aux valeurs distinctes de l'échange des variables ayant le même type de données sans employer une variable provisoire.

L'algorithme

Les algorithmes de permutation de norme exigent l'utilisation d'une variable de mémoire temporaire. Using l'algorithme d'échange de XOR, cependant, aucune mémoire temporaire n'est nécessaire. L'algorithme est comme suit : X : = X XOR Y Y : = X XOR Y X : = X XOR Y L'algorithme correspond typiquement à trois instructions du code machine . Par exemple, en code de système/370 d'IBM : XR R1, R2 XR R2, R1 XR R1, R2 là où R1 et R2 sont les registres et chaque opération de XR laisse son résultat dans le registre appelé dans le premier argument.

Cependant, le problème demeure toujours que si le X et le y emploient le même endroit de stockage, la valeur stockée dans cet endroit sera mise à zéro dehors par la première instruction de XOR, et demeure alors zéro ; ce ne sera pas " ; permuté avec l'itself" ;.

Rendre résistant que l'échange de XOR fonctionne

L'opération binaire XOR au-dessus des chaînes binaires a les propriétés suivantes (où le $\backslash \; oplus$ dénote XOR) :
L1. Commutativity : $A\; \backslash \; oplus\; B\; =\; B\; \backslash \; oplus\; A$
L2. Associativity : $(A\; \backslash \; oplus\; B)\; \backslash \; oplus\; C\; =\; A\; \backslash \; oplus\; (B\; \backslash \; oplus\; C)$
L3. l'identité de de existe : il y a un $Z\; de\; valeur\; =\; des\; 0$ tels que $A\; \backslash \; oplus\; Z\; =\; A$ pour n'importe quel $A$
L4. Chaque élément de a un inverse : pour chaque $A$, il y a un $A^\; de\; valeur\; \{-\; \backslash \; !\; 1\}$ tels que $A\; \backslash \; oplus\; A^\; \{-\; \backslash \; !\; 1\}\; =\; Z$
L4a. en fait, chaque élément est son propre inverse : $A\; \backslash \; oplus\; A\; =\; 0$.

Les quatre premières propriétés sont la définition d'un groupe abélien . Le bout est un dispositif structural du XOR pas nécessairement partagé par d'autres groupes abéliens ou groupes en général.

Supposer que nous avons deux registres R1 et R2, comme dans la table ci-dessous, avec le A de valeurs initiales et le B respectivement. Nous effectuons les opérations ci-dessous dans l'ordre, et réduisons nos résultats using la liste de propriété ci-dessus.

Coder l'exemple

Une fonction du C qui met en application l'algorithme d'échange de XOR : lang=" de xorSwap vide (*x d'international, *y) d'international { si (x ! = y) { ^= de *x *y ; *x *y de ^= ; ^= de *x *y ; } } Noter que le code ne permute pas les nombres entiers passés immédiatement, mais le premier vérifie si leurs endroits de mémoire sont distincts. Ceci enlèvera des problèmes provoqués par le crénelage possible .

Le corps de cette fonction est parfois vu raccourci au if (x ! = y) *x^=*y^=*x^=*y ; . Cependant, c'est C inadmissible, en raison d'un manque d'ordre de dirige

Raisons pour l'usage dans la pratique

L'algorithme n'est pas rare en code inclus d'assemblée, où il y a souvent l'espace très limité disponible pour une variable provisoire d'échange, et cette forme d'échange peut également éviter une charge/magasin qui peuvent être beaucoup plus rapides que l'opération équivalente using une variable provisoire. Sur quelques architectures, certaines opérations exigent de leurs opérandes d'être en particulier des registres, exigeant un échange ; et tout le " disponible ; temporary" ; les registres peuvent être en service stockant d'autres données. Quelques compilateurs de linéarisation de que peut produire du code using XOR permutent dedans ces situations.

Raisons d'action d'éviter dans la pratique

Sur les unités centrales de traitement (de bureau) modernes, la technique de XOR est considérablement plus lente qu'using une variable provisoire pour faire la permutation. Une raison est que les unités centrales de traitement modernes tâchent d'exécuter des commandes en parallèle ; voir la canalisation d'instruction de . Dans la technique de XOR, les entrées à chaque opération dépendent des résultats de l'opération précédente, ainsi elles doivent être exécutées dans l'ordre strictement séquentiel. Si l'efficacité est concernée énorme, on lui conseille d'examiner les vitesses de la technique de XOR et de la variable provisoire permutant sur l'architecture cible.

L'instruction de XCHG

Travail moderne des compilateurs de linéarisation à côté de traduire le code ils sont donnés dans une représentation couler-basée interne qu'ils transforment de plusieurs manières avant de produire leur rendement de machine-code. Ces compilateurs sont pour identifier et optimiser un échange (provisoire-basé) conventionnel que pour identifier les rapports de langage de haut niveau évolué qui correspondent à un échange de XOR. Beaucoup de fois, ce qui est écrite pendant qu'un échange en code à niveau élevé est traduit par le compilateur en note interne simple que deux variables ont permuté des adresses de mémoire, plutôt que toute quantité de code machine. D'autres fois, quand l'architecture cible le soutient, le compilateur peut employer une instruction simple de XCHG (échange) qui effectue l'échange dans une opération simple.

Une opération de XCHG était disponible aussi il y a bien longtemps que 1964, sur le PDP-6 (où ce s'est appelé l'échange) et en 1970 sur le Datacraft 6024 séries (où ce s'est appelé le XCHG). Le Intel 8086 , libérés en 1978, a également inclus une instruction appelée XCHG. Chacun des trois de ces instructions permutées s'inscrit aux inscriptions, ou aux registres à la mémoire, mais ne pouvait pas permuter le contenu de deux endroits de mémoire. Le Motorola opération de s EXG de 68000 'peut seulement permuter des inscriptions aux registres. Le PDP-10 a hérité de l'instruction d'échange de PDP-6, mais le PDP-11 (la machine sur lequel le langage de programmation du C a été développé) n'a pas fait.

Cependant, l'instruction de XCHG dans les processeurs modernes (par exemple x86 ) devrait seulement être employée pour permuter les registres et pas la mémoire , car une instruction implicite de la SERRURE de peut être imposée par le processeur aux endroits de mémoire impliqués de sorte que l'opération soit le atomique.

Crénelage

L'échange de XOR est également compliqué dans la pratique par le crénelage . Comme remarquable ci-dessus, si une tentative est faite XOR-permuter le contenu d'un certain endroit avec lui-même, le résultat est que l'endroit est mis à zéro dehors et sa valeur perdue. Par conséquent, la permutation de XOR ne doit pas être employée aveuglément dans un langage de haut niveau évolué si le crénelage est possible.

Si la langue laisse, les détails laids de la permutation devraient être cachés à l'intérieur d'un macro ou d'une fonction intégrée . Non seulement fera-t-elle le clairifiant de code, mais il sera également possible de commuter à une routine de permutation différente au besoin.

Variations

Le principe fondamental de l'algorithme d'échange de XOR peut être appliqué à n'importe quelle opération binaire réversible. Le remplacement de XOR par l'addition et la soustraction donne légèrement un différent, mais en grande partie l'équivalent, formulation : procédé AddSwap (variété X, Y de de : nombre entier) ; le commencent si le du <> Y de X commencent alors X : = X + Y ; Y : = DE X/Y ; X : = DE X/Y extrémité extrémité À la différence de l'échange de XOR, cette variation exige que le langage fondamental de processeur ou de programmation emploie une méthode telle que l'arithmétique modulaire ou le Bignums pour garantir que le calcul du X + du Y ne peut pas causer une erreur due au débordement de nombre entier de . Par conséquent, on le voit plus rarement dans la pratique que l'échange de XOR.

Voir également

Différence symétrique
Liste chaînée du XOR

.

Random links:

Stockholm (ville), le Wisconsin | Marcheur de R. Tracy | Rue de Nicholson, Melbourne | Trams de Londres | Ordre du mérite des forces de police | Algoritmo_del_intercambio_de_XOR

© 2007-2009 encyclopediefrancaise.com; le texte de cet article est distribué sous les termes de GFDL; en.wikipedia.org