Documentation Center

  • Trial Software
  • Product Updates

or, _or

Logical "or"

Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

Syntax

b1 or b2
_or(b1, b2, …)

Description

b1 or b2 represents the non-exclusive logical ‘or' of the Boolean expressions b1, b2.

MuPAD® uses a three state logic with the Boolean constants TRUE, FALSE, and UNKNOWN. These are processed as follows:

orTRUEFALSEUNKNOWN
TRUETRUETRUETRUE
FALSETRUEFALSEUNKNOWN
UNKNOWNTRUEUNKNOWNUNKNOWN

Boolean expressions may 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 etc. are used to construct Boolean expressions.

_or(b1, b2, ...) is equivalent to b1 or b2 or .... This expression represents FALSE if each single expression evaluates to FALSE. It represents TRUE if at least one expression evaluates to TRUE. It represents UNKNOWN if at least one expression evaluates to UNKNOWN and all others evaluate to FALSE.

_or() returns FALSE.

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 etc. only if they are composed of numbers of type Type::Real. Cf. Example 2.

Use simplify with the option logic to simplify expressions involving symbolic Boolean subexpressions. Cf. Example 3.

The precedences of the logical operators are as follows: The operator not is stronger binding than and, i.e, not b1 and b2 = (not b1) and b2. The operator and is stronger binding than xor, i.e., b1 and b2 or b3 = (b1 and b2) xor b3. The operator xor is stronger binding than or, i.e., b1 xor b2 or b3 = (b1 xor b2) or b3. The operator or is stronger binding than ==>, i.e., b1 or b2 ==> b3 = (b1 or b2) ==> b3. The operator ==> is stronger binding than <=>, i.e., b1 ==> b2 <=> b3 = (b1 ==> b2) <=> b3.

If in doubt, use brackets to make sure that the expression is parsed as desired.

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 not (FALSE or TRUE)

FALSE and UNKNOWN, TRUE and UNKNOWN

FALSE or UNKNOWN, TRUE or UNKNOWN

not UNKNOWN

Example 2

Logical operators simplify subexpressions that evaluate to the constants TRUE, FALSE, UNKNOWN.

b1 or b2 and TRUE

FALSE or ((not b1) and TRUE)

b1 and (b2 or FALSE) and UNKNOWN

FALSE or (b1 and UNKNOWN) or x < 1

TRUE and ((b1 and FALSE) or (b1 and TRUE))

However, equalities and inequalities are not evaluated:

(x = x) and (1 < 2) and (2 < 3) and (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) or (b1 and (not b2)) and (1 < 2)

simplify(%, logic)

Example 4

The Boolean functions _and and _or accept arbitrary sequences of Boolean expressions. The following call uses isprime to check whether all elements of the given set are prime:

set := {1987, 1993, 1997, 1999, 2001}: 
_and(isprime(i) $ i in set)

The following call checks whether at least one of the numbers is prime:

_or(isprime(i) $ i in set)

delete set:

Parameters

b1, b2, …

Boolean expressions

Return Values

Boolean expression.

Overloaded By

b, b_1, b_2

See Also

MuPAD Functions

Was this topic helpful?