Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
Is there an operator equivalent of nor? For example, my favorite color is neither green nor blue.
And the code would be equivalent to:
// example one
if (color!="green" && color!="blue") {
}
// example two
if (x nor y) {
// x is false and y is false
}
Although mainstream languages do not have dedicated NOR and NAND operators, some lesser-known languages (for example, some "golfing" languages) do. For example, APL has ⍱ and ⍲ for NOR and NAND, respectively.
Another class of examples can be found in hardware design languages such as VHDL, Verilog, etc. NAND and NOR gates are quite useful in hardware design due to usually being cheaper (requiring fewer transistors) than the equivalent circuit made from AND/OR/NOT gates, which is one of the reasons hardware design languages tend to include them; another reason is that they can be useful for certain bit-fiddling tricks.
No, there is no nor operator in any high level mainstream programming language.
Mainly because it is difficult to read:
not on the first operand, but the reader only understand this afterwards(x nor y) with (x and not y) instead of ((not x) and (not y))or semantic which doesn't applynor is an elementary hardware gate that can be used to make all the other logical gates. So one could argue that all the other logical operators are combinations and nor is the simplest elementary logical operator.
However, what's true for the hardware is not necessarily true to the humans. And despite it's popularity at hardware level, some mainstream CPUs do not even offer a NOR in their assembler instruction set (e.g. x86).
Readability matters. And sometimes it can be improved by other means.
For example:
if x not in [1,2] // use of 'in' or 'not in' operator instead of x!=1 and x!=2
if x==1 or x==2
action A
else
action B
instead of
if x!=1 and x!=2
action B
else
action A
Some languages also offer loop instructions that allow to express conditions either with while or with until, letting you choose the more "positive" way. These instructions are for example until c do ... in ruby, do until c ... in vb, or repeat ... until c in pascal and its descendants.
For example:
Until (x==1 or x==2) do
...
is equivalent to:
While (x!=1 and x!=2)
...
Now if you still prefer the nor syntax, you could define a function, but only if you don't expect a shortcut to happen:
If ( nor(x,y) ) // attention, x and y will always be evaluated
...
There is a readability advantage of the function over the operator, because the reader immediately understands that the negation applies to all arguments. In some languages you can define a function with a variable number of arguments.
while (not (x == 1 or x == 2)) as I find the x != 1 and x != 2 version hard to read, and find "x is neither 1, nor 2" much easier to process than "x is not 1, and x is not 2".
Repeat... Until always executes the loop body at least once. If x is 1, the loop body is still executed, but not repeated. The While loop won't execute the body in this case.
nor(x,y) are always evaluated depends on the language and how nor() is implemented. There are languages (D, Io, …) where the called function can decide if and when to evaluate arguments.
Feb 6, 2018 at 16:23
@KilianFoth's comment on the question is spot on.
You can synthesize nor from not and or:
if (x nor y)
is exactly the same as
if (not (x or y))
Introducing nor as a separate operator would introduce redundancies to the language, which are neither needed, nor wanted (or - which are not needed and not wanted).
Similarly, I am not aware of any language having a nand operator - probably because it can be synthesized from not and and operators.
You could, in theory, create a language with only nand or only nor operators. All of and, or, and not could then by synthesied from them.
The only problem is that this would be ridiculously unwieldy.
For examples, see NOR logic and NAND logic on Wikipedia.
nor isn’t included. Otherwise, why do languages have and and or? They’re redundant, thanks to De Morgan. In fact, you could substitute all three conventional logical operators (and, or, not) by providing just nor, as you rightly observed.
Feb 6, 2018 at 13:34
and, or and not -- because that's what most human languages use. Once you match the mental model of and/or/not, then nor & nand become redundant. Their redundancy is even encoded in their names: "n(ot )and" and "n(ot )or". If we had distinct, pre-existing English terms for them, and not just synthesized ones, then you'd probably see them more often.
not, and, or. For instance some BASIC dialects (GW-BASIC, QuickBASIC, …) have exclusive or XOR, implication IMP (→ NOT(x XOR y)), and equivalence EQV (→ NOT(x) OR y) as additional operators.
Feb 7, 2018 at 14:30
Yes, APL and some of its dialects have nor (and nand). In APL, nor is denoted ⍱ (since ∨ is or and ~ is not):
∇ result←ExampleOne color
:If (color≡'green')⍱(color≡'blue')
result←'warm'
:Else
result←'cold'
:EndIf
∇
∇ result←ExampleTwo(x y)
:If x⍱y
result←'x is false and y is false'
:Else
result←'at least one of them is true'
:EndIf
∇
This answer is from the assembler language for a computer made in the mid 1960s. That's pretty obscure, but in some respects it addresses your question.
DEC (Digital Equipment Corporation) launched the PDP-6 computer in the mid 1960s. This machine had a total of 64 instructions that were boolean operations on two operands (including some degenerate cases). These 64 instructions were really 16 operators with 4 variants in each operator.
Two of the operators, ANDCB and ORCB implemented NOR and NAND respectively (unless I am mixed up on the double negative logic). You can see the opcode table. The opcode table is actually for the PDP-10 computer, a successor to the PDP-6.
If you look at the numerical instruction in binary, it gets more interesting. It turns out that for all the opcodes in the range 400-477 (octal), four bits in the instruction itself provide a four bit truth table for 16 possible boolean operators. Some of these operators ignore one or both of the inputs. For example SETZ and SETO ignore both of the inputs.
The designers of the PDP-6 exploited this fact to implement all these instructions with less logic than it would have taken to implement only some of them. Some of these instructions appeared rarely, if ever, in assembly language code. But they were all there.
So ANDCB is the equivalent of NOR. (again, unless I got my logic backwards, in which case ORCB is the equivalent).
Perl has the unless keyword that lets you invert conditionals:
unless ($color eq 'green' or $color eq 'blue') {
# code
}
While not NOR operator, you can express your intent in a similar way.
The nor operator as you described it would not be repeatable, which is bound to lead to lots of difficult to spot bugs.
Your "Example 2" is essentially this:
if (false nor false) {
becomes
if (true) {
But try that again with three variables and see what happens:
if (false nor false nor false) {
becomes
if ((false nor false) nor false) {
becomes
if (true nor false) {
becomes
if (false) {
orand!, and because double negatives are rarely used - most people find them especially hard to read.color not in ['green', 'blue']