What are XAND and XOR

Question

What are XAND and XOR? Also is there an XNot

Answer 1

Hmm.. well I know about XOR (exclusive or) and NAND and NOR. These are logic gates and have their software analogs.

Essentially they behave like so:

XOR is true only when one of the two arguments is true, but not both.

F XOR F = F
F XOR T = T
T XOR F = T
T XOR T = F

NAND is true as long as both arguments are not true.

F NAND F = T
F NAND T = T
T NAND F = T
T NAND T = F

NOR is true only when neither argument is true.

F NOR F = T
F NOR T = F
T NOR F = F
T NOR T = F

Answer 2

The XOR definition is well known to be the odd-parity function. For two inputs:

A XOR B = (A AND NOT B) OR (B AND NOT A)

The complement of XOR is XNOR

A XNOR B = (A AND B) OR (NOT A AND NOT B)

Henceforth, the normal two-input XAND defined as

A XAND B = A AND NOT B

The complement is XNAND:

A XNAND B = B OR NOT A

A nice result from this XAND definition is that any dual-input binary function can be expressed concisely using no more than one logical function or gate.

            +---+---+---+---+
   If A is: | 1 | 0 | 1 | 0 |
  and B is: | 1 | 1 | 0 | 0 |
            +---+---+---+---+
    Then:        yields:     
+-----------+---+---+---+---+
| FALSE     | 0 | 0 | 0 | 0 |
| A NOR B   | 0 | 0 | 0 | 1 |
| A XAND B  | 0 | 0 | 1 | 0 |
| NOT B     | 0 | 0 | 1 | 1 |
| B XAND A  | 0 | 1 | 0 | 0 |
| NOT A     | 0 | 1 | 0 | 1 |
| A XOR B   | 0 | 1 | 1 | 0 |
| A NAND B  | 0 | 1 | 1 | 1 |
| A AND B   | 1 | 0 | 0 | 0 |
| A XNOR B  | 1 | 0 | 0 | 1 |
| A         | 1 | 0 | 1 | 0 |
| B XNAND A | 1 | 0 | 1 | 1 |
| B         | 1 | 1 | 0 | 0 |
| A XNAND B | 1 | 1 | 0 | 1 |
| A OR B    | 1 | 1 | 1 | 0 |
| TRUE      | 1 | 1 | 1 | 1 |
+-----------+---+---+---+---+

Note that XAND and XNAND lack reflexivity.

This XNAND definition is extensible if we add numbered kinds of exclusive-ANDs to correspond to their corresponding minterms. Then XAND must have ceil(lg(n)) or more inputs, with the unused msbs all zeroes. The normal kind of XAND is written without a number unless used in the context of other kinds.

The various kinds of XAND or XNAND gates are useful for decoding.

XOR is also extensible to any number of bits. The result is one if the number of ones is odd, and zero if even. If you complement any input or output bit of an XOR, the function becomes XNOR, and vice versa.

I have seen no definition for XNOT, I will propose a definition:

Let it to relate to high-impedance (Z, no signal, or perhaps null valued Boolean type Object).

0xnot 0 = Z
0xnot 1 = Z
1xnot 0 = 1
1xnot 1 = 0

Answer 3

In most cases you won't find an Xand, Xor, nor, nand Logical operator in programming, but fear not in most cases you can simulate it with the other operators.

Since you didn't state any particular language. I won't do any specific language either. For my examples we'll use the following variables.

A = 3
B = 5
C = 7

and for code I'll put it in the code tag to make it easier to see what I did, I'll also follow the logic through the process to show what the end result will be.

NAND

Also known as Not And, can easily be simulated by using a Not operator, (normally indicated as ! )

You can do the following

if(!((A>B) && (B<C)))

if (!(F&&T))
if(!(F))
If(T)

In our example above it will be true, since both sides were not true. Thus giving us the desired result

NOR

Also known as Not OR, just like NAND we can simulate it with the not operator.
if(!((A>B) || (B<C)))

if (!(F||T))
if(!(T))
if(F)

Again this will give us the desired outcomes

XOR

Xor or Exlcusive OR only will be true when one is TRUE but the Other is FALSE

If (!(A > C && B > A) && (A > C || B > A) )

If (!(F && T) && (F || T) )
If (!(F) && (T) )
If (T && T )
If (T)

So that is an example of it working for just 1 or the other being true, I'll show if both are true it will be false.

If ( !(A < C && B > A) && (A < C || B > A) )

If ( !(T && T) && (T ||T) )
If ( !(T) && (T) )
If ( F && T )
If (F)

And both false

If (!(A > C && B < A) && (A > C || B < A) )

If (!(F && F) && (F || F) )
If (!(F) && (F) )
If (T && F )
If (F)

And the picture to help

XAND

And finally our Exclusive And, this will only return true if both are sides are false, or if both are true. Of course You could just call this a Not XOR (NXOR)

Both True If ( (A < C && B > A) || !(A < C || B > A) )

If ((T&&T) || !(T||T))
IF (T || !T)
If (T || F)
IF (T)

Both False If ( (A > C && B < A) || !(A > C || B < A) )

If ( (F && F) || !(F ||F))
If ( F || !F)
If ( F || T)
If (T)

And lastly 1 true and the other one false. If ((A > C && B > A) || !(A > C || B > A) )

If ((F && T) || ! (F || T) )
If (F||!(T))
If (F||F)
If (F)

Or if you want to go the NXOR route...
If (!(!(A > C && B > A) && (A > C || B > A)))

If (!(!(F && T) && (F || T)) )
If (!(!(F) && (T)) )
If (!(T && T) )
If (!(T))
If (F)

Of course everyone else's solutions probably state this as well, I am putting my own answer in here because the top answer didn't seem to understand that not all languages support XOR or XAND for example C uses ^ for XOR and XAND isn't even supported.

So I provided some examples of how to simulate it with the basic operators in the event your language doesn't support XOR or XAND as their own operators like Php if ($a XOR $B).

As for Xnot what is that? Exclusive not? so not not? I don't know how that would look in a logic gate, I think it doesn't exist. Since Not just inverts the output from a 1 to a 0 and 0 to a 1.

Anyway hope that helps.

Answer 4

Guys, don´t scare the crap out of others (hey! just kidding), but it´s really all a question of equivalences and synonyms:

firstly:

"XAND" doesn´t exist logically, neither does "XNAND", however "XAND" is normally thought-up by a studious but confused initiating logic student.(wow!). It com from the thought that, if there´s a XOR(exclusive OR) it´s logical to exist a "XAND"("exclusive" AND). The rational suggestion would be an "IAND"("inclusive" AND), which isn´t used or recognised as well. So:

 XNOR <=> !XOR <=> EQV

And all this just discribes a unique operator, called the equivalency operator(<=>, EQV) so:

A  |  B  | A <=> B | A XAND B | A XNOR B | A !XOR B | ((NOT(A) AND B)AND(A AND NOT(B)))
---------------------------------------------------------------------------------------
T  |  T  |    T    |     T    |     T    |     T    |                T    
T  |  F  |    F    |     F    |     F    |     F    |                F    
F  |  T  |    F    |     F    |     F    |     F    |                F    
F  |  F  |    T    |     T    |     T    |     T    |                T    

And just a closing comment: The 'X' prefix is only possible if and only if the base operator isn´t unary. So, XNOR <=> NOT XOR <=/=> X NOR.

Peace.

Answer 5

OMG, a XAND gate does exist. My dad is taking a technological class for a job and there IS an XAND gate. People are saying that both OR and AND are complete opposites, so they expand that to the exclusive-gate logic:

XOR: One or another, but not both.

Xand: One and another, but not both.

This is incorrect. If you're going to change from XOR to XAND, you have to flip every instance of 'AND' and 'OR':

XOR: One or another, but not both.

XAND: One and another, but not one.

So, XAND is true when and only when both inputs are equal, either if the inputs are 0/0 or 1/1