What type of operator can be used to determine whether a specific relationship?

2.4.1 Relational Expressions With Vectors and Matrices

Relational operators can be used with vectors and matrices. For example, let's say that there is a vector vec, and we want to compare every element in the vector to 5 to determine whether it is greater than 5 or not. The result would be a vector (with the same length as the original) with logical true or false values.

>> vec = [5 9 3 4 6 11];

>> isg = vec > 5

isg =

 1 × 6 logical array

 0 1 0 0 1 1

Note that this creates a vector consisting of all logical true or false values. Although the result is a vector of ones and zeros, and numerical operations can be done on the vector isg, its type is logical rather than double.

>> doubres = isg + 5

doubres =

 5 6 5 5 6 6

>> whos

 Name Size Bytes Class Attributes

 doubres 1x6 48 double

 isg 1x6 6 logical

 vec 1x6 48 double

To determine how many of the elements in the vector vec were greater than 5, the sum function could be used on the resulting vector isg:

>> sum(isg)

ans =

 3

What we have done is to create a logical vector isg. This logical vector can be used to index into the original vector. For example, if only the elements from the vector that are greater than 5 are desired:

>> vec(isg)

ans =

 9 6 11

This is called logical indexing. Only the elements from vec for which the corresponding element in the logical vector isg is logical true are returned.

Quick Question!

Why doesn’t the following work?

 >> vec = [5 9 3 4 6 11];

 >> v = [0 1 0 0 1 1];

 >> vec(v)

 Array indices must be positive integers or logical values.

To create a vector or matrix of all logical 1s or 0s, the functions true and false can be used.

>> false(2)

ans =

 0 0

 0 0

>> true(1,5)

ans =

 1 1 1 1 1

Beginning with R2016a, the ones and zeros functions can also create logical arrays directly.

>> logone = ones(1,5, 'logical')

logone =

 1 1 1 1 1

>> class(logone)

ans =

logical

1.6 Relational Expressions

Expressions that are conceptually either true or false are called relational expressions; they are also sometimes called Boolean expressions or logical expressions. These expressions can use both relational operators, which relate two expressions of compatible types, and logical operators, which operate on logical operands.

The relational operators in MATLAB are:

All of these concepts should be familiar, although the actual operators used may be different from those used in other programming languages, or in mathematics classes. In particular, it is important to note that the operator for equality is two consecutive equal signs, not a single equal sign (as the single equal sign is already used as the assignment operator).

For numerical operands, the use of these operators is straightforward. For example, 3 < 5 means “3 less than 5”, which is, conceptually, a true expression. In MATLAB, as in many programming languages, “true” is represented by the logical value 1, and “false” is represented by the logical value 0. So, the expression 3 < 5 actually displays in the Command Window the value 1 (logical) in MATLAB. Displaying the result of expressions like this in the Command Window demonstrates the values of the expressions.

>> 3 < 5

ans =

 logical

 1

>> 2 > 9

ans =

 logical

 0

>> class(ans)

ans =

 'logical'

The type of the result is logical, not double. MATLAB also has built-in true and false.

>> true

ans =

 logical

 1

In other words, true is equivalent to logical(1) and false is equivalent to logical(0).

Starting in R2016b, the output in the Command Window shows a header for most classes except for the default number type double, char, and string. If the type of a number result is not the default of double, the type (or class) is shown above the resulting value, as in the underlined “logical” in the previous expressions. However, in order to save room, these types will frequently not be shown for the rest of the book. Note: the class names char and string are not shown because the class is obvious from the single quotes (for char) or double quotes (for string).

Although these are logical values, mathematical operations could be performed on the resulting 1 or 0.

>> logresult = 5 < 7

logresult =

 1

>> logresult + 3

ans =

 4

Comparing characters (e.g., ‘a’ < ‘c’) is also possible. Characters are compared using their ASCII equivalent values in the character encoding. So, ‘a’ < ‘c’ is a true expression because the character ‘a’ comes before the character ‘c’.

>> 'a' < 'c'

ans =

 1

The logical operators are:

All logical operators operate on logical or Boolean operands. The not operator is a unary operator; the others are binary. The not operator will take a logical expression, which is true or false, and give the opposite value. For example, ~(3 < 5) is false as (3 < 5) is true. The or operator has two logical expressions as operands. The result is true if either or both of the operands are true, and false only if both operands are false. The and operator also operates on two logical operands. The result of an and expression is true only if both operands are true; it is false if either or both are false. The or/and operators shown here are used for scalars, or single values. Other or/and operators will be explained in Chapter 2.

The || and && operators in MATLAB are examples of operators that are known as short-circuit operators. What this means is that if the result of the expression can be determined based on the first part, then the second part will not even be evaluated. For example, in the expression:

2 < 4 || 'a' == 'c'

the first part, 2 < 4, is true so the entire expression is true; the second part ‘a’ == ‘c’ would not be evaluated.

In addition to these logical operators, MATLAB also has a function xor, which is the exclusive or function. It returns logical true if one (and only one) of the arguments is true. For example, in the following only the first argument is true, so the result is true:

>> xor(3 < 5, 'a' > 'c')

ans =

 1

In this example, both arguments are true so the result is false:

>> xor(3 < 5, 'a' < 'c')

ans =

 0

Given the logical values of true and false in variables x and y, the truth table (see Table 1.1) shows how the logical operators work for all combinations. Note that the logical operators are commutative (e.g., x || y is the same as y || x).

Table 1.1. Truth Table for Logical Operators

As with the numerical operators, it is important to know the operator precedence rules. Table 1.2 shows the rules for the operators that have been covered thus far in the order of precedence.

Table 1.2. Operator Precedence Rules

Quick Question!

Assume that there is a variable x that has been initialized. What would be the value of the expression

 3 < x < 5

if the value of x is 4? What if the value of x is 7?

Practice 1.3

Think about what would be produced by the following expressions, and then type them in to verify your answers.

 3 == 5 + 2

 'b' < 'a' + 1

 10 > 5 + 2

 (10 > 5) + 2

 'c' == 'd' - 1 && 2 < 4

 'c' == 'd' - 1 || 2 > 4

 xor('c' == 'd' - 1, 2 > 4)

 xor('c' == 'd' - 1, 2 < 4)

 10 > 5 > 2

Note: be careful about using the equality and inequality operators with numbers. Occasionally, roundoff errors appear, which means that numbers are close to their correct value but not exactly. For example, cos(pi/2) should be 0. However, because of a roundoff error, it is a very small number but not exactly 0.

>> cos(pi/2)

ans =

 6.1232e-17

>> cos(pi/2) == 0

ans =

 0

Example

A package that provides signed arithmetic operations on integers represented as bit vectors might include a relational operator, defined as shown in Figure 10-11. The function negates the sign bit of each operand, then compares the resultant bit vectors using the predefined relational operator from the package standard. The full selected name for the predefined operator is necessary to distinguish it from the function being defined. If the return expression were written as “tmp1 < tmp2”, it would refer to the function in which it occurs, creating a circular definition.

Exercises

11.1

In the body of the chapter we defined U_ versions of the regular relational operators, including operators like MATCHING that are fundamentally just shorthand. But what about the PACK and UNPACK shorthands? Would U_PACK and U_UNPACK operators make sense?

Does the following identity hold?

USING ( ACL ) : r1 INTERSECT r2 ≡

 USING ( ACL ) : r1 MINUS ( USING ( ACL ) : r1 MINUS r2 )

Consider the operator U_JOIN. Assume for simplicity that the packing and unpacking are to be done on the basis of a single attribute A. Confirm that the following identity holds:

USING ( A ) : rl JOIN r2 ≡

 WITH ( tl := r1 RENAME { A AS X },

 t2 := r2 RENAME { A AS Y } ,

 t3 := t1 JOIN t2 ,

 t4 := t3 WHERE X OVERLAPS Y ,

 t5 := EXTEND t4 : { A := X INTERSECT Y } ,

 t6 := T5 { ALL BUT X , Y } ) :

 PACK t6 ON ( A )

Confirm also that if r1 and r2 are initially packed on A, the final PACK step is unnecessary.

Conditional Operations

Where a logical condition is tested in a while, if, or for statement, relational operators are used. One variable is compared with a set value or another variable, and the block is executed if the condition is true. The conditional operators are shown in Table 2.7. Note that double equals is used in the relational test to distinguish it from the assignment operator.

Table 2.7. Conditional Operators

Sometimes, a conditional test needs to combine tests on several values. The tests can be compounded by using logical operators, as follows:

AND condition:if ((a>b)&&(c=d))...OR condtion:if  ((a>b)||(c=d))...

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.1 The one-line if statement

In the last example MATLAB has to make a decision; it must decide whether or not r is greater than 0.5. The if construct, which is fundamental to all computing languages, is the basis of such decision making. The simplest form of if in a single line is

 if condition; statements; end

Note the following points:

condition is usually a logical expression (i.e., it contains a relational operator), which is either true or false. The relational operators are shown in Table 2.4. MATLAB allows you to use an arithmetic expression for condition. If the expression evaluates to 0, it is regarded as false; any other value is true. This is not generally recommended; the if statement is easier to understand (for you or a reader of your code) if condition is a logical expression.

Table 2.4. Relational operators.

If condition is true, statement is executed, but if condition is false, nothing happens.

condition may be a vector or a matrix, in which case it is true only if all of its elements are nonzero. A single zero element in a vector or matrix renders it false.

 if condition statement, end

Here are more examples of logical expressions involving relational operators, with their meanings in parentheses:

b^2 < 4*a*c (b2<4 ac)

x >= 0 (x⩾0)

a ~= 0 (a≠0)

b^2 == 4*a*c (b2=4ac)

Remember to use the double equal sign (==) when testing for equality:

 if x == 0; disp( 'x equals zero'); end

Exercises

The following statements all assign logical expressions to the variable x. See if you can correctly determine the value of x in each case before checking your answer with MATLAB.

(a) x = 3 > 2

(b) x = 2 > 3

(c) x = -4 <= -3

(d) x = 1 < 1

(e) x = 2 ~= 2

(f) x = 3 == 3

(g) x = 0 < 0.5 < 1

Did you get item (f)? 3 == 3 is a logical expression that is true since 3 is undoubtedly equal to 3. The value 1 (for true) is therefore assigned to x. After executing these commands type the command whos to find that the variable x is in the class of logical variables.

What about (g)? As a mathematical inequality,

0<0.5<1

is undoubtedly true from a nonoperational point of view. However, as a MATLAB operational expression, the left-hand < is evaluated first, 0 < 0.5, giving 1 (true). Then the right-hand operation is performed, 1 < 1, giving 0 (false). Makes you think, doesn't it?

9.1 The Predefined Packages standard and env

In previous chapters, we have introduced numerous predefined types and operators. We can use them in our VHDL models without having to write type declarations or subprogram definitions for them. These predefined items all come from a special package called standard, located in a special design library called std. A full listing of the standard package is included for reference in Appendix A.

Because nearly every model we write needs to make use of the contents of this library and package, as well as the library work, VHDL includes an implicit context clause of the form

library std, work; use std.standard.all;

at the beginning of each design unit. Hence we can refer to the simple names of the predefined items without having to resort to their selected names. In the occasional case where we need to distinguish a reference to a predefined operator from an overloaded version, we can use a selected name, for example:

result := std.standard.“<” ( a, b );

Example 9.1 A comparison operator for signed binary-coded integers

A package that provides signed arithmetic operations on integers represented as bit vectors might include a relational operator, defined as follows:

function “<” ( a, b : bit_vector ) return boolean is

  variable tmp1 : bit_vector(a’range) := a;

  variable tmp2 : bit_vector(b’range) := b;

begin

  tmp1(tmp1‘left) := not tmp1(tmp1‘left);

  tmp2(tmp2‘left) := not tmp2(tmp2‘left);

  return std.standard.”<” ( tmp1, tmp2 );

end function “<”;

The function negates the sign bit of each operand, then compares the resultant bit vectors using the predefined relational operator from the package standard. The full selected name for the predefined operator is necessary to distinguish it from the function being defined. If the return expression were written as “tmp1 < tmp2”, it would refer to the function in which it occurs, creating a circular definition.

VHDL-87, -93, and -2002

A number of new operations were added to VHDL in the 2008 revision. They are not available in earlier versions of the language. In summary, the changes are

The types boolean_vector, integer_vector, real_vector, and time_vector are predefined (see Section 4.2.1). The predefined operations on boolean_vector are the same as those defined for bit_vector. The predefined operations on integer_vector include the relational operators (“=”, “/=”, “<”, “>”, “<=”, and “>=”) and the concatenation operator (“&”). The predefined operations on real_vector and time_vector include the equality and inequality operators (“=” and  “/=”) and the concatenation operator (“&”).

The array/scalar logic operations and logical reduction operations are predefined for bit_vector and boolean_vector, since they are arrays with bit and boolean elements, respectively.

The matching relational operators “?=”, “?/=”, “?>”, “?>=”, “?<”, and “?<=” are predefined for bit. Further, the operators “?=” and “?/=” are predefined for bit_vector.

The condition operator “??” is predefined for bit.

The operators mod and rem are predefined for time, since it is a physical type.

The maximum and minimum operations are predefined for all of the predefined types.

The functions rising_edge and falling_edge are predefined for bit and boolean. Prior to VHDL-2008, the bit versions of these functions were declared in the package numeric_bit (see Section 9.2.3). However, that was mainly to provide consistency with the std_ulogic versions defined in the std_logic_1164 package. They rightly belong with the definition of the type on which they operate; hence, VHDL-2008 includes them in the package standard. The VHDL-2008 revision of the numeric_bit package redefines the operations there as aliases for the predefined versions. (We discuss aliases in Chapter 11.)

The to_string operations are predefined for all scalar types and for bit_vector. Further, the to_bstring, to_ostring, and to_hstring operations and associated aliases are predefined for bit_vector.

VHDL also provided a second special package, called env, in the std library. The env package includes operations for accessing the simulation environment provided by a simulator. First, there are procedures for controlling the progress of a simulation:

procedure stop (status: integer);

procedure stop;

procedure finish (status: integer);

procedure finish;

When the procedure stop is called, the simulator stops and accepts further input from the user interface (if interactive) or command file (if running in batch mode). When the procedure finish is called, the simulator terminates; simulation cannot continue. The versions of the procedures that have the status parameter use the parameter value in an implementation-defined way. They might, for example, provide the value to a control script so that the script can determine what action to take next.

The env package also defines a function to access the resolution limit for the simulation:

function resolution_limit return delay_length;

We described the resolution limit in Section 2.2.4 when we introduced the predefined type time. One way in which we might use the resolution_limit function is to wait for simulation time to advance by one time step, as follows:

wait for env.resolution_limit;

Since the resolution limit, and hence the minimum time by which simulation advances, can vary from one simulation run to another, we cannot write a literal time value in such a wait statement. The use of the resolution_limit function allows us to write models that adapt to the resolution limit used in each simulation. We need to take care in using this function, however. It might be tempting to compare the return value with a given time unit, for example:

if env.resolution_limit > ns then  -- potentially illegal!

  …  -- do coarse-resolution actions

else

  …  -- do fine-resolution actions

end if;

The problem is that we are not allowed to write a time unit smaller than the resolution limit used in a simulation. If this code were simulated with a resolution limit greater than ns, the use of the unit name ns would cause an error; so the code can only succeed if the resolution limit is less than or equal to ns. We can avoid this problem by rewriting the example as:

if env.resolution_limit > 1.0E–9 sec then

  … -- do coarse-resolution actions

else

  … -- do fine-resolution actions

end if;

For resolution limits less than or equal to ns, the test returns false, so the “else” alternative is taken. For resolution limits greater than ns, the time literal 1.0E-9 sec is truncated to zero, and so the test returns true. Thus, even though the calculation is not quite what appears, it produces the result we want.

VHDL-87, -93, and -2002

These versions do not provide the env package. Some tools might provide equivalent functionality through implementation-defined mechanisms.

Predicated Execution

Architectures that support predicated execution let the compiler avoid some conditional branches. In iloc, we write a predicated instruction by including a predicate expression before the instruction. To remind the reader of the predicate's purpose, we enclose it in parentheses and follow it with a question mark. For example,

(r17) add ra, rb ⇒ rc

indicates an add operation (ra + rb) that executes if and only if r17 contains true.

Predicated Execution

an architectural feature in which some operations take a boolean-valued operand that determines whether or not the operation takes effect

The example in Figure 7.9a shows the strength of predicated execution. The code is simple and concise. It generates two predicates, r1 and r2. It uses them to control the code in the then and else parts of the source construct. In Figure 7.9b, predication leads to the same code as the boolean-comparison scheme.

The processor can use predication to avoid executing the operation, or it can execute the operation and use the predicate to avoid assigning the result. As long as the idled operation does not raise an exception, the differences between these two approaches are irrelevant to our discussion. Our examples show the operations required to produce both the predicate and its complement. To avoid the extra computation, a processor could provide comparisons that return two values, both the boolean value and its complement.

Section Review

The implementation of boolean and relational operators involves more choices than the implementation of arithmetic operators. The compiler writer must choose between a numerical encoding and a positional encoding. The compiler must map those decisions onto the set of operations provided by the target processor's isa.

In practice, compilers choose between numerical and positional encoding based on context. If the code instantiates the value, numerical encoding is necessary. If the value's only use is to determine control flow, positional encoding often produces better results.

Review Questions

If the compiler assigns the value zero to false, what are the relative merits of each of the following values for true? One? Any non-zero number? A word composed entirely of ones?

How might the treewalk code generation scheme be adapted to generate positional code for boolean and relational expressions? Can you work short-circuit evaluation into your approach?

Finding Values That Meet Selection Critieria

The following example demonstrates how array elements greater than a threshold are found:

The where function returns the indices of the nonzero elements in an array or array expression. Thus, in the previous example, where returned the nonzero indices of the expression (arr gt 35) (recall that relational operators in IDL return 0 for false, and 1 for true). So where returned the locations of arrays elements where the expression (arr gt 35) was true. This is easier to see when the relational operator is separated from the where call:

The array result now contains a value of 1 wherever the expression (arr gt 35) is true in arr. Now where can be called to retrieve the locations of the nonzero elements in result:

The expression passed to where may be as complicated as desired. For example, to find the array values greater than 35 that are also multiples of four:

You should always account for the possibility that where will not find any nonzero values in the input array or expression (i.e., no values meet the prescribed conditions). In this case, where returns a scalar long equal to-1:

For this reason the where function accepts an optional count argument, which returns the number of nonzero elements found:

The optional count argument is recommended whenever where is used within an IDL program.