什么是xand和xor

XOR 是 独占或 . 它是一个逻辑二元运算符,要求两个操作数中的一个为true,但不能同时为两者。

所以这些说法是正确的:

TRUE XOR FALSE
FALSE XOR TRUE

这些说法是错误的:

FALSE XOR FALSE
TRUE XOR TRUE

真的没有“排他性”和(或 XAND )因为从理论上讲,它与 异或 . 也没有 XNOT 自从 NOT 是一元运算符,它对其单个操作数求反(基本上它只是将布尔值翻转到相反的值),因此它不支持任何独占性概念。

伙计们,别把别人吓跑了(嘿!只是开个玩笑),但它实际上是一个等价物和同义词的问题:

首先:

“xand”在逻辑上不存在,“xnand”也不存在,但是“xand”通常是由一个勤奋但困惑的逻辑学生想到的。(哇!)它从这样的思想出发:如果有一个异或(exclusive or),它的逻辑就是存在一个“xand”(“exclusive”and)。合理的建议将是一个“IAND”(“包容性”和),它也不被使用或认可。所以:

 XNOR <=> !XOR <=> EQV

所有这些只是描述了一个独特的操作符,叫做等价操作符(<=>,eqv),所以:

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    

仅结束注释:“x”前缀仅在且仅当基运算符不是一元时才可能。所以,x nor<=>不是xor<=/=>x nor。

和平。

XOR是独占的或。这意味着“XOR'D的两项中有一项是正确的,但不是两项都是正确的。”

TRUE XOR TRUE : FALSE
TRUE XOR FALSE : TRUE
FALSE XOR TRUE : TRUE
FALSE XOR FALSE: FALSE

Wikipedia's XOR Article

我没听说过。

在查尔斯·佩佐德写的题为“代码”的书中,他说有6个门。有AND逻辑门、OR门、NOR门、NAND门和XOR门。他还提到了6号门,简单地称之为“巧合门”,并暗示它不经常使用。他说,它有一个异或门的相反输出,因为当一个异或门有两个等式的真或假边时,它的输出是“假”,而只有一个异或门的输出是真的,方程的一个边是真的,另一个边是假的,它不等于注意哪个。巧合正好与此相反,因为对于巧合门,如果一个是真的,另一个是假的(不管是哪个),那么在这两种情况下,它的输出都将是“假”。巧合门输出为“真”的方法是两边都是“假”或“真”。如果两者都是错的,则符合门将评估为真。如果两者都是真的,那么在这种情况下,重合闸也将输出“真”。

因此,在XOR门输出“假”的情况下,重合门将输出“真”。在异或门输出“真”的情况下,重合门输出“假”。

隐马尔可夫模型。。我知道xor(exclusive or)和nand and nor。它们是逻辑门,并有它们的软件类似物。

本质上,他们的行为是这样的:

只有当两个参数中的一个为真,而不是同时为真时,XOR才为真。

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

只要两个参数都不是真的,NAND就是真的。

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

也不是只有当两个论点都不是真的时候才是真的。

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

除此之外,因为我只是在处理这个问题,如果你想找一个“等价门”或“创造门”作为你的X,你真正拥有的只是“等价门”。

如果你考虑一下,考虑到上面的xor:

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

我们希望xand应该是:

F XAND F = T
F XAND T = F
T XAND F = F
T XAND T = T

这不是完全一样吗?

F == F = T
F == T = F
T == F = F
T == T = T

这里有一个简单的参数来看看二进制逻辑门是从哪里来的,使用已经出现的真值表。

有六个表示交换操作,其中op b==b op a。每个二元运算符都有一个关联的三列真值表来定义它。前两列可以固定用于所有运算符的定义表。

考虑第三列。它是由四个二进制数字组成的序列。有16种组合,但是交换性的约束有效地从真值表中删除了一行,所以它只有8行。另外两个被击倒,因为所有的真理或谎言都不是有用的门。这些是熟悉的或,and,和xor,加上它们的否定。

没有Xand或Xnot这样的东西。有NAND,它与

TRUE and TRUE   : TRUE
TRUE and FALSE  : FALSE
FALSE and TRUE  : FALSE
FALSE and FALSE : FALSE


TRUE nand TRUE   : FALSE
TRUE nand FALSE  : TRUE
FALSE nand TRUE  : TRUE
FALSE nand FALSE : TRUE

xor定义是众所周知的奇校验函数。 对于两个输入:

a xor b=(a与非b)或(b与非a)

xor的补码是xnor

a xnor b=(a和b)或(非a和非b)

此后,正常的两个输入x定义为

A X和B=A而不是B

补码是xnand:

A x和B=B或不是A

这个xand定义的一个很好的结果是,任何双输入二进制函数都可以用不超过一个逻辑函数或门来简洁地表示。

            +---+---+---+---+
   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 |
+-----------+---+---+---+---+

注意xand和xnand缺乏自反性。

如果我们添加编号类型的排他与对应的minterms对应,那么XNAND定义是可扩展的。那么xand必须具有CEIL(lg(n))或更多输入,未使用的msb都为零。除非在其他类型的上下文中使用,否则普通类型的xand没有数字。

各种各样的xand或xnand门对解码很有用。

XOR也可以扩展到任意数量的位。如果一个数是奇数,则结果为1;如果是偶数,则结果为零。如果对XOR的任何输入或输出位进行补码,则函数将变为XNOR,反之亦然。

我没有看到XNOT的定义,我将提出一个定义:

让它与高阻抗相关(Z,无信号,或者可能是空值布尔型对象)。

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

维基上的真相表澄清了 http://en.wikipedia.org/wiki/Logic_gate 没有X,这就是第一部分“合法性”问题的结尾。 [关键是,没有它,你总能做到。]

我个人把XNot(它也不存在)误认为是NAND,理论上也不认为是制造所有其他门所需要的唯一东西。 link

我相信混淆源于这样一个事实,即你可以使用NAND或NOR(来创建其他的东西[但它们不需要一起使用]),所以它被认为是一个既不是NAND又不是NAND的东西,这基本上让人忘记了用剩下的名称XNOT来代替它,而不是用它来代替它。这就是我错误地称之为XNot的意思,它不是NAND就是NOR。

我想,在快速讨论中,人们也可能会错误地尝试使用xand,就像我使用xnot一样,指的是“单个门(以各种方式复制)使所有其他门成为逻辑现实”。

xor(不是既不是也不是两者)b'0110'是相反的 (双)iff(if和only if)b'1001'。

这就是你要找的: https://en.wikipedia.org/wiki/XNOR_gate

这是逻辑表:

A B   XOR XNOR
0 0   0   1 
0 1   1   0
1 0   1   0
1 1   0   1

xnor有时被称为xand。

XOR的行为就像Austin解释的那样,作为一个独占的OR,或者A或者B,但不是两者都有,两者都不会产生错误。

两个输入有16个可能的逻辑运算符,因为真值表由4个组合组成。有16种可能的方法来排列两个布尔参数和相应的输出。

他们的名字都是根据 this wikipedia article

看一看

x   y      A    B   C   D   E   F   G   H   I   J   K   L   M   N

·   ·      T    ·   T   ·   T   ·   T   ·   T   ·   T   ·   T   ·
·   T      ·    T   T   ·   ·   T   T   ·   ·   T   T   ·   ·   T
T   ·      ·    ·   ·   T   T   T   T   ·   ·   ·   ·   T   T   T
T   T      ·    ·   ·   ·   ·   ·   ·   T   T   T   T   T   T   T

A) !(x OR y)    
B) !(x) AND y   
C) !(x) 
D) x AND !(y)   
E) !(y) 
F) x XOR y  
G) !(x AND y)   
H) x AND y  
I) !(x XOR y)   
J) y    
K) !(x) OR y    
L) x    
M) x OR !(y)    
N) x OR y

首先是逻辑,然后是名称,可能是以前命名的模式。

因此,0+0=0;0+1=1;1+0=1;1+1=1-出于某种原因,这被称为或。

然后0-0=0;0-1=1;1-0=1;1-1=0-看起来像或除了…我们称之为XOR。

另外,0*0=0;0*1=0;1*0=0;1*1=1-出于某种原因,调用和。

然后0~0=0;0~1=0;1~0=0;1~1=0-看起来像,除了……让我们称之为xand。

天哪,一个X门确实存在。我爸爸正在上技术课找工作,那儿有一扇大门。人们说“或”和“都是” 完成 相反的,所以它们扩展到了排他门逻辑:

XOR:一个 或 另一个,但不是两个。

xand:一个 和 另一个,但不是两个。

这是不正确的。如果要从xor更改为xand,则必须翻转“and”和“and”或“or”的每个实例:

XOR:一个 或 另一个,但不是两个。

xand:一个 和 另一个,但不是一个。

因此,当且仅当两个输入相等时,xand才为true,无论输入是0/0还是1/1

在大多数情况下,您在编程中找不到xand、xor、nor、nand逻辑运算符,但在大多数情况下,您不必担心可以用其他运算符来模拟它。

因为你没有说任何特定的语言。我也不会做任何具体的语言。对于我的示例,我们将使用以下变量。

A = 3
B = 5
C = 7

对于代码,我将把它放在代码标签中,以便更容易地看到我做了什么,我还将按照逻辑来完成整个过程,以显示最终结果是什么。

与非门

也被称为not和,可以通过使用not运算符(通常表示为!)

您可以执行以下操作

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

如果(!)(F&T)
如果(!)(f)
如果(t)

在我们上面的例子中,这是真的,因为双方都不是真的。从而给我们期望的结果

也不

也被称为not或,就像nand一样,我们可以用not操作符来模拟它。
if(!((A>B) || (B<C)))

如果(!)(f t)
如果(!)(t)
f(f)

这将再次给我们带来期望的结果。

异或

xor或exlcustive或仅当一个为真,另一个为假时才为真

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

如果(!)(F&T)和(F&T)
如果(!)(f)和(t)
如果(T&T)
如果(t)

所以这是一个例子,它只适用于一个或另一个是真的,我会证明如果两者都是真的,那就是假的。

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

如果(!)(T&T)和(T&T)
如果(!)(t)和(t)
如果(F&T)
f(f)

都是假的

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

如果(!)(f&f)&f;(f_f))
如果(!)(f)和(f)
如果(T&F)
f(f)

还有要帮助的图片

XAND

最后,我们的排他性和,只有当双方都是错误的,或者双方都是正确的,这才会返回真。当然,您可以将其称为非XOR(nxor)

都是真的 If ( (A < C && B > A) || !(A < C || B > A) )

如果((T&T&T)!(t t)
如果(T)!t)
如果(t f)
如果(t)

都是假的 If ( (A > C && B < A) || !(A > C || B < A) )

如果((F&F)!(F F)
如果(F)!f)
如果(F t)
如果(t)

最后一个是真的,另一个是假的。 If ((A > C && B > A) || !(A > C || B > A) )

如果((F&T)!(f t)
如果(F)!(t)
如果(F F)
f(f)

或者如果你想去nxor路线…
If (!(!(A > C && B > A) && (A > C || B > A)))

如果(!)(!(F&T)和(F&T)))
如果(!)(!(f)和(t)))
如果(!)(T&T)
如果(!)(t)
f(f)

当然,其他人的解决方案也可能会说明这一点,我将自己的答案放在这里,因为上面的答案似乎并不理解并非所有语言都支持XOR或Xand,例如C对XOR和Xand使用^甚至不受支持。

因此,我提供了一些示例,说明如何在您的语言不支持XOR或Xand作为自己的运算符(如PHP)时使用基本运算符来模拟它。 if ($a XOR $B) .

至于Xnot,那是什么?排他性不是吗?所以不是吗?我不知道这在逻辑门中是怎么看的,我认为它不存在。因为不只是将输出从1反转为0,将输出从0反转为1。

不管怎样,希望能有所帮助。