# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# `xor`, `_xor`

Logical exclusive-or

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

```b1 xor b2
_xor(`b1, b2, …`)
```

## Description

`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.

## Examples

### Example 1

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`

### Example 2

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(%)`

### Example 3

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)`

## Parameters

 `b1, b2, …` Boolean expressions

## Return Values

Boolean expression.

`b`, `b_1`, `b_2`