What is the result of logical or relational expression in C True False 0 or 1 0 if an expression is false and any positive number if an expression is true?

Relational Expressions

A logical expression is a statement that evaluates to either “true” or “false.” Relational operators are a type of logical operator, and compare two values such as 5 > 4 (true) or 3 ≤ −4 (false). matlab returns a 1 to indicate true and 0 to indicate false. matlab has several types of relational operators; some of the most common are listed below:

Note that one of the most common relational statements, the test to see if two scalar numbers are the same, is not = but rather ==.

In the example below, the function called password() tests to see if the input is “secret” and outputs a 1, if so, and 0, otherwise:

function result = password(input)

% password tests to see if the input is

% the string 'secret'

result = isequal(input, 'secret');

Practice Problems

Modify the above function to take a number as an argument and test to see if it is 999. If so, it outputs a 1; otherwise, it outputs a 0. Call the function problem10(). ©

2.8.5 Logical operators

More complicated logical expressions can be constructed using the three logical operators: & (and), | (or), and ~ (not). For example, the quadratic equation

ax2+bx+c=0

has equal roots, given by −b/(2a), provided that b2−4ac =0 and a≠0 (Figure 2.2). This translates into the following MATLAB statements:

if (b ^ 2 - 4*a*c == 0) & (a ~= 0)
      x = -b / (2*a);
end

Of course, a, b, and c must be assigned values prior to reaching this set of statements. Note the double equal sign in the test for equality; see Chapter 5 for more on logical operators.

Abstract

The chapter introduces the use of logical expressions in a variety of selection statements. First, if statements are introduced, and then if-else statements. This is expanded upon with the use of else and elseif clauses. Nesting and cascading if statements are explained. The switch statement is also demonstrated, as is the concept of choosing from a menu. Finally, “is” functions that return logical true or false are covered. Examples are shown in functions and scripts. Throwing errors is shown. Common mistakes that result in logical errors are also explained.

4.1 If-Else Statements

A branching statement, If-Else Statement, or If-Statement for short, is a code construct that executes blocks of code only if certain conditions are met. These conditions are represented as logical expressions.

CONSTRUCTION: Simple If Statement Syntax

if logical expression:

 code block

CONSTRUCTION: Simple If-Else Statement Syntax

if logical expression:

 code block 1

else:

 code block 2

The word “if” is a keyword. When Python sees an if-statement, it will determine if the associated logical expression is true. If it is true, then the code in code block will be executed. If it is false, then the code in the if-statement will not be executed. The way to read this is “If the logical expression is true then do code block.” Similarly, if the logical expression in the if-else-statement is true, then the code in code block1 will be executed. Otherwise, code block2 will be executed.

When there are several conditions to consider, you can include elif statements; if you want a condition that covers any other case, then you may use an else statement. Let P, Q, and R be three logical expressions in Python. The following example shows multiple branches.

Note! Python gives the same level of indentation to every line of code within a conditional statement.

CONSTRUCTION: Extended If-Else Statement Syntax

if logical expression P:

 code block 1

elif logical expression Q:

 code block 2

elif logical expression R:

 code block 3

else:

 code block 4

In the previous code, Python will first check if P is true. If P is true, then code block 1 will be executed, and then the if-statement will end. In other words, Python will not check the rest of the statements once it reaches a true statement. If P is false, then Python will check if Q is true. If Q is true, then code block 2 will be executed, and the if-statement will end. If it is false, then R will be executed, and so forth. If P, Q, and R are all false, then code block 4 will be executed. You can have any number of elif statements (or none) as long as there is at least one if-statement (the first statement). You do not need an else statement, but you can have, at most, one else statement. The logical expressions after the if and elif (i.e., such as P, Q, and R) will be referred to as conditional statements.

TRY IT! Write a function my_thermo_stat(temp, desired_temp). The return value of the function should be the string "Heat" if temp is less than desired_temp minus 5 degrees, "AC" if temp is more than the desired_temp plus 5, and "off" otherwise.

EXAMPLE: What will be the value of y after the following script is executed?

We can also insert more complicated conditional statements using logical operators.

EXAMPLE: What will be the value of y after the following code is executed?

Note that if you want the logical statement a, this is considered as two conditional statements, a and x. Python allows you to type a < x < b as well. For example,

A statement is called nested if it is entirely contained within another statement of the same type as itself. For example, a nested if-statement is an if-statement that is entirely contained within a clause of another if-statement.

EXAMPLE: Think about what will happen when the following code is executed. What are all the possible outcomes based on the input values of x and y?

Note! As before, Python gives the same level of indentation to every line of code within a conditional statement. The nested if-statement should be indented by an additional four white spaces. You will get an IndentationError if the indentation is not correct, as we saw earlier when discussing how to define functions.

There are many logical functions that are designed to help you build branching statements. For example, you can ask if a variable has a certain data type with function isinstance. There are also functions that can tell you information about arrays of logicals like any, which computes to true if any element in an array is true, and false otherwise, and all, which computes to true only if all the elements in an array are true.

Sometimes you want to design your function to check the inputs of a function to ensure that your function will be used properly. For example, the function my_adder in the previous chapter expects doubles as input. If the user inputs a list or a string as one of the input variables, then the function will throw an error or have unexpected results. To prevent this, you can put a check to tell the user the function has not been used properly. This and other techniques for controlling errors are explored further in Chapter 10. For the moment, you only need to know that we can use the raise statement with a TypeError exception to stop a function's execution and throw an error with a specific text.

EXAMPLE: Modify my_adder to throw out a warning if the user does not input numerical values. Try your function for nonnumerical inputs to show that the check works. When a statement is too long, we can use the

symbol to break a line into multiple lines.

There is a large variety of erroneous inputs that your function may encounter from users, and it is unreasonable to expect that your function will catch them all. Therefore, unless otherwise stated, write your functions assuming the functions will be used properly.

The remainder of the section gives a few more examples of branching statements.

TRY IT! Write a function called is_odd that returns "odd" if the input is an odd number and "even" if it is even. You can assume that input will be a positive integer.

TRY IT! Write a function called my_circ_calc that takes a numerical number, r, and a string, calc, as input arguments. You may assume that r is positive, and that calc is either the string "area" or "circumference". The function my_circ_calc should compute the area of a circle with radius, r, if the string calc is the "area", and the circumference of a circle with radius, r, if calc is the "circumference".

Note! The function here is not limited to a single value input but can be executed using NumPy arrays as well (i.e., the same operation will apply on each item of the array). See the following example where we calculate the circumferences for radius as [2, 3, 4] using a NumPy array.

3.3.1.1 Specification Location

Baresi and Young [1] present groups of oracles according to certain similarities, among them: oracles of pure specification language, embedded assertion languages, and extrinsic interface contracts. These three oracle contracts differ from each other in the way they are written with respect to the code.

Oracles based on pure specification are those in which the tester uses a specification language to describe the desired behavior of a system or part of it for later use as a source for the oracle, i.e., as the oracle information. Such languages are usually not designed with the concern of being automatically interpreted. Therefore, defining procedures to interpret oracles which use such a source of information can be challenging.

Embedded assertion languages1 allow one to insert expressions of intent within the code to be tested. They usually represent pre- or postconditions at some control point in the program. Such expressions are checked during the code execution and, if a violation is detected, a message is presented. In this way, they are executable code which may be an extension of the same language used to implement the SUT or from a different language. Java and other programming languages natively support embedded assertions. There are also specification notation languages, such as Anna [97–99] and JML [85,100], in which the assertions can be written in the code. In such cases, assertions are marked with reserved words recognized by an outside interpreter/compiler and executed as a separated part of the code.

For example, consider a Java code snippet which was modified to increase its performance, where the tester wants to be sure that the output is the same as its original output. In this context, one may introduce an assertion in the SUT to ensure that an error will occur if the refactoring method for coordinate calculation differs from its original. As an illustration, in Fig. 3.6, the first line contains the embedded assertion recognized by the Java compiler and, consequently, JVM (Java Virtual Machine) given the reserved word assert. During the program execution, if the expression is not true, a runtime error is thrown. Technically, this is the oracle strategy explored by JUnit (Fig. 3.5 and Section 2.3).

Extrinsic interface contracts keep the specification, in the form of assertions, separate from the implementation and less closely tied to the target programming language. There are several assertion languages that allow extrinsic interface contracts, known as ADL (Architecture Description Language). Developers must define the bindings between the specification and the functions in the program [101,102]. This is usually achieved by the use of wrappers. A wrapper is a checker that surrounds the component under test [103] without modifying its code. For instance, when testing a given class on an OO code, another class (the wrapper) is created with the same interface as the original but with other methods which are responsible to check some constraint.

Figure 3.7 presents a code example, adapted from Shukla et al. [90], in which the objective is testing a class which is a list of integers, using an insert method. The code represents the list class to be tested. A list of integers, in this program, should have a maximum length of 1000 elements and 3 methods: insert(), size(), and exists(). To test the insert() method, two basic assumptions are considered: (i) if a value is inserted, it must exist in the list; and (ii) if a value is inserted, the list must have one more element than before the value is inserted. Both assumptions can be tested without inserting intrusive code (embedded assertions) with a wrapper.

Figure 3.8 represents such a wrapper. It extends the original class and overrides the method to be tested. The new insert() method (i) retrieves the size of the list before the insertion, (ii) calls the method under test, (iii) retrieves the size of the list after the insertion, and (iv) calls the method which will evaluate the assumptions. If the value is not inserted into the list or if the list does not contain one more element after an insertion, a message is sent. A driver calls the method insert() from the wrapper and the class under test is evaluated without the need for intrusive code.

Other specification languages may be related to the SUT by some variation of the presented approaches. For example, a specification does not need to be a contract, but can be any other language paradigm which can be translated by the oracle procedure. The mapping between oracle information and SUT can also be achieved by instrumenting the SUT to dump the target outputs to a log which can then be used by the oracle procedure in the analysis.

Exercise 1: Boolean Functions

The functions AND and OR may be used to test two or more logical expressions, while the NOT function is used to reverse the truth value of a logical expression. The XOR function returns TRUE when one, and only one, of the logical expressions is true.

On Sheet1 of a new workbook, enter the values in A1:B5 of Fig. 5.1. Use the information in columns D and F to enter formulas in columns C and E.

Save the workbooks as Chap5.xlsx.

By default, Excel aligns Boolean values (TRUE and FALSE) centered horizontally in their cells.

Note that if in this worksheet you entered the formula = A2 > 5, the result would be TRUE. Excel would compare the letter a (a text data type) with the literal 5 (also a text data type): the ASCII value for the letter a is 97, and that for the digit 5 is 53.

There are some common combinations that are useful to know. In the following table, A and B may be expressions or references to cells containing the values TRUE or FALSE. You may wish to experiment with these nested formulas on Sheet1.

Logical operators

Logical operators are designed for operations with the true or false values within the logical expressions. They can be used as addresses in another vector, matrix or array; see, for instance, the last three example commands.

In MATLAB®, there are three logical operators: & (logical AND), | (logical OR), and ~ (logical NOT). Like the relational operators, they can be used as arithmetical operators and with scalars, matrices and arrays. Comparison is element-by-element with logical 1 or 0 accordingly as the result is true or false respectively. MATLAB® also has equivalent logical functions: and(A,B) equivalent to A&B, or(A,B) - to A|B, not(A,B) - to A~B. If the logical operators are performed on logical variables, the results are according to the rules of Boolean algebra. In operations with logical and/ or numerical variables, the results are logical 1 or 0.

Some examples are:

Among the MATLAB® logical functions is find, which in its simplest forms reads as

i=find(x) or i=find(A>c)

where i is a vector of the place addresses (indices), where non-zero elements of the x (first form) are located, or are elements of A larger than c (second form; in this case, any of the relational operators can also be used, e.g., <, > = , etc.); for example, vector T = [11 8.5 5.5 0–1.5], thus

>> i = find(T)

i =

1 2 3 5

>> i = find(T<6)

i =

3 4 5

The order in which combinations of relational, logical and conditional operators is executed (so-called precedence rules) are available in advanced MATLAB® courses. The order of execution necessary for such an operator can also be reached using parentheses.

1.3 Logical Expressions and Operators

A logical expression is a statement that can either be true or false. For example, a is a logical expression. It can be true or false depending on what values of a and b are given. Note that this differs from a mathematical expression which denotes a truth statement. In the previous example, the mathematical expression a means that a is less than b, and values of a and b where a≥b are not permitted. Logical expressions form the basis of computing, so for the purposes of this book, all statements are assumed to be logical rather than mathematical unless otherwise indicated.

In MATLAB, a logical expression that is true will compute to the value “TRUE.” A false expression will compute to the value “FALSE.” For the purpose of this book, “TRUE” is equivalent to 1, and “FALSE” is equivalent to 0. Distinguishing between the numbers 1 and 0 and the logical values “TRUE” and “FALSE” is beyond the scope of this book, but it is covered in more advanced books on computing. Logical expressions are used to pose questions to MATLAB. For example, “3<4 ” is equivalent to, “Is 3 less than 4?” Since this statement is true, MATLAB will compute it as 1. However, 3>4 is false, therefore MATLAB will compute it as 0.

Comparison operators compare the value of two numbers, and they are used to build logical expressions. MATLAB reserves the symbols > ,>=,<,<=,∼=,==, to denote “greater than,” “greater than or equal,” “less than,” “less than or equal,” “not equal,” and “equal,” respectively.

TRY IT!

Compute the logical expression for “Is 5 equal to 4?” and “Is 2 smaller than 3?”

Logical operators are operations between two logical expressions that, for the sake of discussion, we call P and Q. The fundamental logical operators we will use herein are AND, OR, and NOT, which in MATLAB are denoted by &&, ∥, and ∼, respectively. There are other logical operators, but they are equivalent to combinations of these three operators. P AND Q is true only if P and Q are both true. P OR Q is true if either P or Q is true or if both P and Q are true. It is important to note that OR in MATLAB is “inclusive” OR, meaning it is true if both P and Q are true. In contrast, “exclusive” OR or XOR is true if either P or Q is true but false if both P and Q are true. If P is true, then NOT P is false, and if P is false, then NOT P is true.

The truth table of a logical operator or expression gives the result of every truth combination of P and Q. The truth tables for AND and OR are given in Figure 1.2.

TRY IT!

Assuming P is true, use MATLAB to determine if the expression (P AND NOT(Q)) OR (P AND Q) is always true regardless of whether or not Q is true. Logically, can you see why this is the case?

First, assume Q is true:

Now assume Q is false:

Just as with arithmetic operators, logical operators have an order of operations relative to each other and in relation to arithmetic operators. All arithmetic operations will be executed before comparison operations, which will be executed before logical operations. Parentheses can be used to change the order of operations.

TRY IT!

Compute (1+3)>(2+5).

TIP!

Even when the order of operations is known, it is usually helpful for you and those reading your code to use parentheses to make your intentions clearer. In the preceding example (1 + 3) > (2 + 5) is clearer than 1 + 3 > 2 + 5.

WARNING!

In MATLAB’s implementation of logic, 1 is used to denote true and 0 for false. However, 1 and 0 are still numbers. Therefore, MATLAB will allow abuses such as ≫ (3>2) + (5>4), which will resolve to 2.

WARNING!

Although in formal logic, 1 is used to denote true and 0 to denote false, MATLAB slightly abuses notation and it will take any number not equal to 0 to mean true when used in a logical operation. For example, 3 && 1 will compute to true. Do not utilize this feature of MATLAB. Always use 1 to denote a true statement.

TRY IT!

A fortnight is a length of time consisting of 14 days. Use a logical expression to determine if there are more than 100,000 seconds in a fortnight.

Appendix A Expression Syntax of UML-RSDS

UML-RSDS uses both classical set theory expressions and OCL. It only uses sets and sequences, and not bags or ordered sets, unlike OCL. Symmetric binary operators such as ∪ and ∩ are written in the classical style, rather than as operators on collections. Likewise for the binary logical operators.

A logical_op is one of =>, &, or. An equality_op is one of =, ∕ =, >, <, <: (subset-or-equal), < =, >=, :, ∕ : (not-in). A factor_op is one of +, ∕, *, −, ∖∕ (union), ⌢ (concatenation of sequences), ∕∖ (intersection). An fe_sequence is a comma-separated sequence of factor expressions. Identifiers can contain “.”.