Een tijdje geleden was er hier een post/reply langsgekomen m.b.t. de XOR operatie en hoe deze exact werkt.

Hierin werd uitgelegd dat de uitleg zoals hij vaak te vinden is. *De XOR is enkel true als een en ook echt maar een input hoog is*.

Volgens die replier klopte dit alleen voor 2-input XOR poorten. Waarbij het voor multi-bit XOR poorten gold dat er een oneven aantal true moesten zijn om de output true te maken.

Dus, bijv:


a^b^c = d
0 0 0 = 0
1 0 0 = 1
1 1 0 = 0
1 1 1 = 1

Etc.
Wat was hier de reden ook alweer voor?

[edit] Ik post/vraag het omdat ik die post/reply niet meer kan vinden :(

De "exclusive" (uitsluitend) in "exclusive-OR" betekent: met uitsluiting van alle andere.
Dus als één ingang hoog is, moet dat uitsluitend (exclusively) die ene ingang zijn.

Dat is de definitie. Dat er ook andere bouwblokjes gemaakt worden die reageren zoals jij beschrijft, kan best; en dat de fabrikant die dan óók XOR noemt, kan ook.
Kijk dus alleen naar de waarheidstabel, dan weet je alles.

Eén oorzaak kan zijn dat iemand XOR-en met 2 ingangen gebruikt en die aan elkaar koppelt tot een grotere poort. Dan krijg je dat gedrag.

Een 3 input xor wordt met 2 2input xor's gemaakt. Daardoor krijg je dat.


A B C A^B (A^B)^C 
0 0 0  0     0
0 0 1  0     1
0 1 0  1     1
0 1 1  1     0  
1 0 0  1     1
1 0 1  1     0
1 1 0  0     0
1 1 1  0     1

[edit] dit was in reply to FET, voordat Bas z'n post poste :P[/edit]

hmmm,

raar ik kan me toch echt wat anders herinneren.. >_< Dan heb ik het helemaal fout onthouden dan denk ik :-)

Ik dacht namelijk dat daarin uitgelegd werd dat vroeger, om multi-bit XOR's te maken dat er een (N-1) aantal XOR poorten voor N aantal inputs gebruikt werden en die dan in serie gezet werden.

Dan krijg je dat wat ik zojuist beschreef namelijk

1^1 = 0,
0^1 = 1

[alwetende-modus]
Ohwell, ook ik kan er wel eens naast zitten
[/alwetende-modus]

XOR functie met meerdere poorten zou een 1 moeten geven bij een oneven aantal 1 en aan de input.
XOR functie wordt over het algemeen gebruikt voor het constateren van bitfouten in geheugens of communicatie. XOR wordt in micro's ( en software ) ook zo gemaakt.

Uit Bas Smit zijn tabel zie ik:

Een xor geeft uitgang '1' als de hoeveelheid '1en' aan de inputs oneven zijn. In dit geval dus 1 of 3. Welke inputs dat precies zijn boeit niet.

Die waarheidstabel van Bas Smit die kende ik dus toch al wel van die *vorige post*.(*)

Dan ben ik wel benieuwd of er multi-bit XOR's bestaan waarbij het inderdaad een *echte* exclusive or is. Als deze niet bestaan ben ik benieuwd hoe je zo iets zou kunnen maken met alleen maar logische poorten.

(*)Had ik het dus toch wel goed onthouden ^^

Op 9 november 2009 16:23:34 schreef Sponcebert: XOR wordt in micro's ( en software ) ook zo gemaakt.

In uC/uP's wordt de XOR alleen gemaakt met 2inputs waardoor de hele multi-bit *gedoe* wegvalt ;-)
Pas als je idd meerdere waardes moet XOR-en krijg je het vorige *probleem*.
Met het enige verschil dat je bij een controller/processor uit een multi-bit/byte XOR kan jumpen dm.v. een branch indien er meer dan een input hoog is. Dit lijkt mij lastiger bij logische poorten?

[Bericht gewijzigd door Daan Timmer op (44%)]

Je hebt helemaal gelijk, ook in je micro en in C is dit een per bit functie, foutje...

Even verder lezend kan de XOR fucntie alleen met twee bits of waardes. Een 4 input poort die een 1 geeft bij precies 1 of een oneven aantal enen is dus geen XOR poort

Op 9 november 2009 16:27:33 schreef Daan Timmer:
Dan ben ik wel benieuwd of er multi-bit XOR's bestaan waarbij het inderdaad een *echte* exclusive or is. Als deze niet bestaan ben ik benieuwd hoe je zo iets zou kunnen maken met alleen maar logische poorten.

a b c d y
0 0 0 1 1
0 0 1 0 1
0 1 0 0 1
1 0 0 0 1
de rest 0

zoiets?
wat dacht je van y<=(a XOR b) XOR (c XOR d); ?
Of moet het met NANDS? :P


(A^B)^(C^D)|A^B=X|C^D=Y|X^Y=Z
 0 0   0 0 |0 0 0|0 0 0|0 0 0
 0 0   0 1 |0 0 0|0 1 1|0 1 1
 0 0   1 0 |0 0 0|1 0 1|0 1 1
 0 0   1 1 |0 0 0|1 1 0|0 0 0
 0 1   0 0 |0 1 1|0 0 0|1 0 1
 0 1   0 1 |0 1 1|0 1 1|1 1 0
 0 1   1 0 |0 1 1|1 0 1|1 1 0
 0 1   1 1 |0 1 1|1 1 0|1 0 1
 1 0   0 0 |1 0 1|0 0 0|1 0 1
 1 0   0 1 |1 0 1|0 1 1|1 1 0
 1 0   1 0 |1 0 1|1 0 1|1 1 0
 1 0   1 1 |1 0 1|1 1 0|1 0 1
 1 1   0 0 |1 1 0|0 0 0|0 0 1
 1 1   0 1 |1 1 0|0 1 1|0 1 1
 1 1   1 0 |1 1 0|1 0 1|0 1 1
 1 1   1 1 |1 1 0|1 1 0|0 0 0

Zo, dat kost ff wat tik werk :p

Ok, werkt dus niet...


(A^B)^(C^D)|A^B=X|C^D=Y|X^Y=Z
 0 0   0 0 |0 0 0|0 0 0|0 0 0 OK
 0 0   0 1 |0 0 0|0 1 1|0 1 1 OK
 0 0   1 0 |0 0 0|1 0 1|0 1 1 OK
 0 0   1 1 |0 0 0|1 1 0|0 0 0 OK
 0 1   0 0 |0 1 1|0 0 0|1 0 1 OK
 0 1   0 1 |0 1 1|0 1 1|1 1 0 OK
 0 1   1 0 |0 1 1|1 0 1|1 1 0 OK
 0 1   1 1 |0 1 1|1 1 0|1 0 1 FOUT
 1 0   0 0 |1 0 1|0 0 0|1 0 1 OK
 1 0   0 1 |1 0 1|0 1 1|1 1 0 OK
 1 0   1 0 |1 0 1|1 0 1|1 1 0 OK
 1 0   1 1 |1 0 1|1 1 0|1 0 1 FOUT
 1 1   0 0 |1 1 0|0 0 0|0 0 1 FOUT
 1 1   0 1 |1 1 0|0 1 1|0 1 1 FOUT
 1 1   1 0 |1 1 0|1 0 1|0 1 1 FOUT
 1 1   1 1 |1 1 0|1 1 0|0 0 0 FOUT

Fout slaat er even op dat de schakeling niet doet wat ik zou willen dat 'ie doet, dus niet op jouw bloederig typerwerk. (dat ik dankbaar kopier :P)

Het gaat fout als AB = 11 of CD=11...

Nieuw voorstel:
y<=((a XOR b) XOR (b XOR d)) AND (NOT ((a AND b) or (B and C)));

Op 9 november 2009 16:07:31 schreef Frederick E. Terman:
De "exclusive" (uitsluitend) in "exclusive-OR" betekent: met uitsluiting van alle andere.

das de mathematische definitie ...
In booleaanse logica is het een parity definitie.

Er zijn xors met 3 en meer ingangen.
http://www.fairchildsemi.com/pf/NC/NC7SZ386.html

Daarom zei ik al dat ze ook anders gemaakt worden.
Eigenlijk klopt dan de naam "exclusive" niet, want die andere ingangen worden dan duidelijk niet uitgesloten.
De datasheet sluit dan ook een waarheidstabel bij, gelukkig. :)

Even voor de duidelijkheid. FET heeft een hele ongebruikelijke definitie voor de XOR die mischien van taalkundige oorsprong is.

Wat FET in zijn achtertuin doet, boeit me niet, maar dan moet ie niet hier mensen op het verkeerde been gaan zetten met een compleet ongebruikelijke definitie voor "XOR".

XOR is een handige functie. Het is namelijk de binaire optelling van twee bits, zonder carry. Als je de "gebruikelijke" definitie gebruikt geldt dat ook voor meer dan twee bits.

Als je afspreekt dat in ieder 8-bit byte, altijd een even aantal enen zit, dan noemen we dat "Even parity". Dan is het 8e bitje gewoon gelijk aan de XOR van de andere zeven. Makkelijk toch? Dat werkt dus wel met de gebruikelijke definitie, en niet met de definitie van FET.

Rew hwwft gelijk als je naar dit kijkt.

http://en.wikipedia.org/wiki/Parity_bit

Maar volgens mij kloppen de voorbeeld prograama's niet. Want bij de laatste 2 zou de ontvangen code correct moeten worden bevonden door de ontvangen.

A wants to transmit: 1001
A computes even parity value: 1^0^0^1 = 0
A sends: 10010
*** TRANSMISSION ERROR ***
B receives: 10011
B computes overall parity: 1^0^0^1^1 = 1 >> dit is volgens mij dan fout omdat de berekende parity gelijk is aan de ontvangen parity

Volgens mij dan
B computes overall parity: 1^0^0^1 gelijk aan 1
B computes overall parity: 0 gelijk aan 1 >> error

B reports incorrect transmission after observing unexpected odd result.

Zit ik goed of zie ik spoken. Boeoeoe boeoeeoe

@rew, je hebt gelijk, echter, als je bijvoorbeeld kijkt naar de XOR definitie van wat wikipedia zegt en ja, ik ben me er van bewust dat wikipedia niet al wetende is ;-), dan klopt de definitie van FET weer wel.

Zie: http://en.wikipedia.org/wiki/Exclusive_disjunction

Maarja, dan heb je het weer over de mathematische versie van de XOR.

Het hangt er maar net vanaf van waar je van uit gaat? FET heeft gelijk wat betreft de mathematische versie, in overige gevallen klopt de parity-versie...

Toch nog wel beetje raar, aangezien de mathematische versie wel ook gebruikelijk is in booleanse logica en dus in digitale systemen.

[Bericht gewijzigd door Daan Timmer op (30%)]

Als je de parity van alle databits en het ontvangen parity bit berekend, moet daar altijd 0 uit komen. Bij een even parity zet je het parity bit zo dat je in totaal op een even aantal komt (toch?).

Zelf vind ik XOR poortjes erg handig als je een interrupt wilt krijgen op meerdere ingangen van een microcontroller; zodra er een lijn van status veranderd, valt het resultaat van een XOR (van willekeurige lengte) ook om. Alleen oppassen dat er niet meerdere bits "tegelijk" (d.w.z., op zeer kleine intervallen) veranderen, want dan gaat het mis.

@Daan Timmer: daar heb je wel een beetje gelijk in (dat dat raar is), maar de XOR is geen bineaire basisfunctie. Zodra je met booleaanse algebra aan de gang gaat, is het vaak ook handiger om hem uit te schrijven.

[Bericht gewijzigd door SparkyGSX op (16%)]

Op 9 november 2009 23:40:37 schreef rew:
Even voor de duidelijkheid. FET heeft een hele ongebruikelijke definitie voor de XOR die mischien van taalkundige oorsprong is.

Wat FET in zijn achtertuin doet, boeit me niet, maar dan moet ie niet hier mensen op het verkeerde been gaan zetten met een compleet ongebruikelijke definitie voor "XOR". [...]

Rustig, rustig :+. Lees mijn post nog eens over.

Ik definieerde niet de XOR, maar zei wat het woord "exclusive" betekent. Omdat TS het over die betekenis had.
Daaronder zei ik dat de gebruikelijke multipoort XOR zich daar niet aan houdt!

Het is trouwens ook niet zo dat de tegenwoordige multipoort XOR zich aan een "booleaanse definitie" zou houden!
In het werk van Boole zelf zie je op bladzijde 39 en verder hoe hij met exclusive OR omgaat (maar zijn notatie is nu niet meer gebruikelijk).

Het hele punt is eigenlijk dat de XOR als functie maar twee ingangen kent. Wat een multipoort doet, en wat je in pariteitscontroles en dergelijke doet, is het herhaald uitvoeren van die functie: eerst op 2 bits, dan op het resultaat samen met het volgende bit, et cetera - zoals ik ook in mijn eerste reply zei.

In de Nederlandse Wiki staat dit correct uitgelegd.

Als je echt een letterlijke "uitsluitende of", dus "eentje maar ook echt niet meer dan eentje" zou willen maken met een behoorlijk aantal ingangen, dan kost dat nog heel wat standaard poortjes denk ik.
Er dan maar gewoon een eprommetje mee programmeren was ooit een aanvaardbare oplossing. :)

XOR is een functie die je maar op twee bits of logische waardes kunt uitvoeren. Uiteraard kun je een poort maken met meer ingangen die ook iets met xor doet ( men name gericht op parity inderdaad , maar hardware CRC is ook een optie ) dan is het dus geen XOR meer maar een samengestelde fuctie.

O, te laat

In de electronica/computerkunde is XOR een bewerking die je op twee (of meer) inputs kan uitvoeren. Voor twee bits is de definitie xor (p,q) = (p != q). Da's een redelijke definitie. Of je kan het definieren via de waarheidstabel.

Voor meer bits heb je geen EXCLUSIVE DISJUNCTIVE OR, maar XOR. De definitie is:


   XOR (X1, X2, ... Xn) = XOR (XOR (X1, X2, ... Xn-1) , Xn) 
                        = XOR (X1, Xor (X2, X3, .... Xn))

Problem solved. :-)

Maar, bestaan er dan helemaal geen IC's die een "Exclusive Disjuntion OR"-multi-bit-input hebben?

Lijkt me wel handig, stel je hebt een versterker waarbij je 4inputs kan selecteren. Dan wil je niet dat twee of meer van deze inputs tegelijkertijd actief zijn. Dan zou je dus zo'n exclusive disjunction moeten hebben over die 4inputs, zodat je zeker weet dat er 1 en maximaal 1 poort actief is.

Zulke dingen bestaan dus *simpel weg* gewoon niet?

Als je 3 ( of meer ) ingangen / binaire waardes hebt kan het niet zo zijn dat A != B, A != C en C !=B. Deze functie zou altijd nul geven. Definitie van een 3 input XOR is dan XOR(a,b,c) = 0

Ik was ook wat verbaast toen bleek dat een EXOR dus inderdaad hoog gaat als er een oneven aantal bits "1" is. Dat is nl niet mijn idee van exclusive.
Het EXOR-ren van registers zou ik eerder denken dat dat alleen een "waar" geeft als er slechts 1 bit hoog is. Dat is namelijk mijn idee van exclusive.

Maar ook als je bv bij de gemiddelde PLC twee registers EXOR't word dit bit na bit gedaan, met als resultaat dat dit een "waar" geeft als er een oneven aantal bits hoog is. Bijvoorbeeld bij een S7 met "XOW".

Dit is helaas niet het enige geval waar 'juistheid' en 'common practice' niet overeenkomen. De enige mogelijk interpretatie van het woord 'exclusive' is zoals FET geeft. Helaas is dat blijkbaar niet zoals het in de praktijk gebruikt wordt :(

Zolang je een XOR consequent ziet als een poortje met twee ingangen is er niks aan het handje toch? Als je met meerdere bits eerst de eerste twee bits exor't, en vervolgens het resultaat met het volgende bitje exor't enz.enz. klopt het "oneven" verhaal gewoon.

De naam exor is gewoon een beetje "odd".