Logical exclusiveor
This functionality does not run in MATLAB.
b_{1} xor b_{2}
_xor(b_{1}, b_{2}, …
)
b1 xor b2
represents the exclusive logical or
of
the Boolean expressions b1
, b2
.
xor
is defined as follows: a xor
b
is equivalent to (a or b) and not (a and b)
.
MuPAD^{®} uses a three state logic with the Boolean constants TRUE
, FALSE
,
and UNKNOWN
.
These are processed as follows:
or  TRUE  FALSE  UNKNOWN 
TRUE  TRUE  TRUE  TRUE 
FALSE  TRUE  FALSE  UNKNOWN 
UNKNOWN  TRUE  UNKNOWN  UNKNOWN 
Boolean expressions can be composed of these constants as well
as of arbitrary arithmetical expressions. Typically, equations, such
as x = y
, and inequalities, such as x
<> y
, x < y
, x <=
y
, are used to construct Boolean expressions.
_xor(b1, b2, ...)
is equivalent to b1
xor b2 xor ...
. This expression represents TRUE
if an odd number
of operands evaluate to TRUE
and the others evaluate to FALSE
.
It represents FALSE
if
an even number of operands evaluate to TRUE
and the others
evaluate to FALSE
.
It represents UNKNOWN
if at least one operand evaluates
to UNKNOWN
.
Combinations of the constants TRUE
, FALSE
, UNKNOWN
inside a Boolean
expression are simplified automatically. However, symbolic Boolean
subexpressions, equalities, and inequalities are not evaluated and
simplified by logical operators. Use bool
to evaluate such expressions to
one of the Boolean constants. Note, however, that bool
can evaluate inequalities x
< y
, x <= y
, and so on only if
they are composed of numbers of type Type::Real
. See Example 2.
Use simplify
with
the option logic
to simplify expressions involving
symbolic Boolean subexpressions. See Example 3.
The precedences of the logical operators are as follows. If in doubt, use parentheses to ensure that the expression is parsed as desired.
The operator not
is stronger binding
than and
, that is, not b1 and b2
= (not
b1) and b2
.
The operator and
is stronger binding
than xor
, that is, b1 and b2 or b3
= (b1
and b2) xor b3
.
The operator xor
is stronger binding
than or
, that is, b1 xor b2 or b3
= (b1
xor b2) or b3
.
The operator or
is stronger binding
than ==>
, that is, b1 or b2 ==>
b3
= (b1 or b2) ==> b3
.
The operator ==>
is stronger
binding than <=>
, that is, b1 ==>
b2 <=> b3
= (b1 ==> b2) <=> b3
.
In the conditional context of if
, repeat
, and while
statements, Boolean expressions
are evaluated via "lazy evaluation" (see _lazy_and
, _lazy_or
). In any other
context, all operands are evaluated.
Combinations of the Boolean constants TRUE
, FALSE
,
and UNKNOWN
are simplified automatically to one
of these constants:
TRUE and (FALSE xor TRUE)
FALSE xor UNKNOWN, TRUE xor FALSE
Logical operators simplify subexpressions that evaluate to the
constants TRUE
, FALSE
, UNKNOWN
.
b1 xor b2 and TRUE
FALSE xor ((not b1) and TRUE)
b1 and (b2 xor FALSE) and UNKNOWN
FALSE or (b1 and UNKNOWN) xor x < 1
TRUE xor ((b1 and FALSE) or (b1 and TRUE))
However, equalities and inequalities are not evaluated:
(x = x) and (1 < 2) and (2 < 3) xor (3 < 4)
Boolean evaluation is enforced via bool
:
bool(%)
Expressions involving symbolic Boolean subexpressions are not
simplified by and
, or
, not
. Simplification has to be requested
explicitly via the function simplify
:
(b1 and b2) xor (b1 and (not b2)) and (1 < 2)
simplify(%, logic)

Boolean expressions 
Boolean expression.
b
, b_1
, b_2