Operators
Definition:
Operators are means for
constructing expressions.
Syntax:
adding_operator ::= +  
 &
logical_operator ::= and  or
 nand  nor
 xor  xnor
miscellaneous_operator ::= **
 abs  not
multiplying_operator ::= *  /
 mod  rem
relational_operator ::= =  /=
 <  <=
 >  >=
shift_operator ::= sll  srl
 sla  sra
 rol  ror
Description
VHDL has a wide set of different operators, which can be divided into
groups of the same precedence level (priority). The table below lists
operators grouped according to priority level, highest priority first.
Table 1. Operator priority
miscellaneous operators 
**  abs  not 
multiplying operators 
*  /  mod  rem 
sign operators 
+   
adding operators 
+    & 
shift operators 
sll  srl  sla  sra  rol  ror 
relational operators 
=  /=  <  <=  >  >= 
logical operators 
and  or  nand nor  xor  xnor 
The expressions are evaluated form left to right, operations with
higher precedence are evaluated first. If the order should be
different from the one resulting from this rule, parentheses can be
used (Example 1).
The operands, connected with each other by an operator, are evaluated
before the operation described by that operator is carried out. For
some operators the right operand is evaluated only when the left
operand has a certain value assigned to it. The logical operators
such as and, or,
nand, nor
defined for the BIT and BOOLEAN operands belong to those operators.
The operators for the predefined types are defined in the STANDARD
package in the STD library. These operators are functions, which
always return the same value when they are called with the same
values of the actual parameters. These functions are called the pure
function (see function for
details).
LOGICAL OPERATORS
The logical operators and, or,
nand, nor,
xor, xnor
and not are defined for BIT
and BOOLEAN types, as well as for onedimensional arrays containing
the elements of BIT and BOOLEAN. All these operators have the lowest
priority, except for the operator not,
which has the highest priority. The results of the logical operators
for the predefined types are presented in the tables 2 through 8. The
BIT type is represented by the values '0' and '1', while the Boolean
type by True and False.
Table 2. Operator not
A 
not A 
True 
'1' 
False 
'0' 
False 
'0' 
True 
'1' 
Table 3. Operator and
A 
B 
A and B 
True 
'1' 
True 
'1' 
True 
'1' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
False 
'0' 
Table 4. Operator or
A 
B 
A or B 
True 
'1' 
True 
'1' 
True 
'1' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
True 
'1' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
Table 5. Operator xor
A 
B 
A xor B 
True 
'1' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
True 
'1' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
Table 6. Operator nand
A 
B 
A nand B 
True 
'1' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
True 
'1' 
True 
'1' 
False 
'0' 
False 
'0' 
True 
'1' 
Table 7. Operator nor
A 
B 
A nor B 
True 
'1' 
True 
'1' 
False 
'0' 
True 
'1' 
False 
'0' 
False 
''0' 
False 
'0' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
True 
'1' 
Table 8. Operator xnor
A 
B 
A xnor B 
True 
'1' 
True 
'1' 
True 
'1' 
True 
'1' 
False 
'0' 
False 
''0' 
False 
'0' 
True 
'1' 
False 
'0' 
False 
'0' 
False 
'0' 
True 
'1' 
RELATIONAL OPERATORS
The relational operators allow checking relation between operands,
i.e. to state whether they are equal, not equal or are ordered in a
way defined by operator (Table 9). Both operands must be of the same
type, and the result received is always of the Boolean type.
Table 9. Relational operations
= 
Equality 
/= 
Inequality 
< 
Ordering „less than” 
<= 
Ordering „less than or equal” 
> 
Ordering „greater than” 
>= 
Ordering „greater than or equal” 
The operators: equality and inequality are predefined for all types
available in the language except the file type. For other relations
the operands must be of a scalar type or onedimensional array types.
The equality operator returns the value TRUE only when both operands
have the same values, and FALSE when the values are different. The
inequality operator returns the value TRUE when the operators are
different and FALSE when they are equal. There are certain rules that
are used to compare operands depending on their type: in case of the
scalar type, the operand values are equal only when the values are
the same. Two values of the composite type are equal only when each
value of the left operand corresponds to the value of the right
operand and vice versa. In the record the corresponding elements have
identical identifiers, and in the array the corresponding elements
are those which appear at the same positions of arrays. In particular
two null arrays of the same type are always equal.
The operators: <, <=, >, and >= return the TRUE logical
value only when the condition in the given relation is met, otherwise
the FALSE value is returned (Example 4).
SHIFT OPERATORS
The shift operators are defined for the onedimensional array with
the elements of the type BIT or BOOLEAN. For the shift operator an
array is the left operand L and integer is the right operand R. The
right operand represents the number of positions the left operand
should be shifted. As the result of shifting, the value of the same
type as the left operand is returned. Table 10 below shows predefined
shift operators.
Table 10. Shift operators
sll 
Shift left logical 
srl 
Shift right logical 
sla 
Shift left arithmetic 
sra 
Shift right arithmetic 
rol 
Rotate left logical 
ror 
Rotate right logical 
The operator sll returns the
value of the L left operand, after it has been shifted R number of
times. If R is equal to 0 or L is the null array, the left operand L
is returned. The single left logical operation replaces L with
concatenation of the rightmost (L'Length 1) elements of L and a
single value T'Left, where T is the element type of L. If R > the
single shift operation is repeated R number of times. If R is a
negative number, the value of the expression L srl
R is returned.
The operator srl returns the
value of the left operand L after it has been shifted to right R
times. In case when R is equal to 0 or L is the null array, the left
operand L is returned. The single shifting operation replaces the
operand L with the concatenation of the leftmost L'Length 1 elements
of L and a single value T'Left, where T is the element type of L. If
R is a negative number then the value of expression L sll
R is returned, otherwise the single shift operation is repeated R
number of times.
The operator sla returns the
value of the left operand L after it has been shifted to the left R
number of times. In case when R is equal to 0 or L is the null array
the left operand L is returned. The single shift operation replaces L
with concatenation of the rightmost L'Length 1 elements of L and a
single value L'Right. If R is a negative number, the value of the
expression L sra R is
returned, otherwise the single shift operation is repeated R number
of times.
The operator sra returns the
value of the left operand L after it has been shifted to the right R
number of times. In case when R is equal to 0 or L is the null array,
the left operand L is returned. The single shift operation replaces L
with a value, which is the result of concatenation whose left
argument is the leftmost L'Length 1 elements of L and whose right
argument is L'Left. If R is a negative number, the value of the
expression L sla R is returned, otherwise the single shift operation
is repeated R number of times.
The operator rol returns the
value of the L left operand after it has been rotated to the left R
times. In case when R is equal to 0 or L is the null array the left
operand L is returned. The single shift operation replaces L with a
value which is the result of concatenation of the rightmost L'Length
1 elements of L and a single value L'Left. If R > 1 the sing.le
shift operation is repeated R times. If R > 1 is a negative
number, the expression L ror
R is returned.
The operator ror returns the
value of the L left operand after it has been rotated to the right R
number of times. In case when R is equal to 0 or L is the null array,
the left operand L is returned. The single shift operation replaces L
with a value which is the result of concatenation whose left argument
is the leftmost L'Length 1 elements of L and whose right argument is
L'Right. If R > 1 the single shift operation is repeated R times.
If R is a negative number, the expression L rol
R is returned.
ADDING OPERATORS
Adding operators consist of addition, subtraction and concatenation.
The adding operators are shown in the Table 11 below.
Table 11. Adding operators
+ 
Addition 
 
Subtraction 
& 
Concatenation 
The adding and subtraction operators perform mathematical operations,
and their operands can be of any numeric type.
The concatenation (&) operator is defined for elements of
onedimensional arrays. In the concatenation, the following
situations can take place:

When both operands are onedimensional arrays of the same type, the
concatenation connects the two arrays into one. The new array
contains the elements from both arrays. The direction of the new
array is the same as the direction in the array of the left operand,
but if the left operand is the null array then it is the same as the
direction of the right operand. In case when both operands are null
arrays, the direction of the right operand is assumed (Example 6).

When one of the operands is a onedimensional array and the second
operand is a scalar of the same type as the elements of that array,
then the result of the concatenation is the same as in the first
point. However, in this case the second operand is treated as a
onedimensional array which contains only one element (Example 6).

In case when both operands are of the same scalar type, then the
result of concatenation is onedimensional array with elements of the
same types as the operands (Example 6).
SIGN OPERATORS
Sign operators are unary operators, i.e. have only one, right
operand, which must be of a numeric type. The result of the
expression evaluation is of the same type as the operand. There are
two sign operators (Table 12).
Table 12. Sign operators
When ( + ) sign operator is used, the operand is returned unchanged,
but In case of (  ) sign operator the value of operand with the
negated sign is returned. Because of the lower priority, the sign
operator in the expression cannot be directly preceded by the
multiplication operator, the exponentiation operator (**) or the abs
and not operators. When
these operators are used then sign operator and its operand should be
enclosed in parentheses (Example 7).
MULTIPLYING OPERATORS
The multiplication and division operators are predefined for all
integers, floating point numbers. Under certain conditions, they may
be used for operations on physical type objects as well. The mod
and rem operators, on the
other hand, are defined only for the integers. When mod
and rem operators are used,
then both the operands and the result are of the same integer type.
The multiplying operators are shown in the Table 13.
Table 13. Multiplying operators
* 
Multiplication 
/ 
Division 
mod 
Modulus 
rem 
Remainder 
MISCELLANEOUS
The two miscellaneous operators are shown in the Table 14.
Table 14. Miscellaneous operators
** 
Exponentiation 
abs 
Absolute value 
The abs operator has only
one operand. It allows defining the operand's absolute value. The
result is of the same type as the operand.
The exponentiation operator has two operands. This operator is
defined for any integer or floating point number. The right operand
(exponent) must be of integer type. When the exponent is the positive
integer, then the left operand is repeatedly multiplied by itself.
When the exponent is the negative number, then the result is a
reverse of exponentiation with the exponent equal to the absolute
value of the right operand (Example 9). If the exponent is equal to 0
the result will be 1.
Examples
Example 1
v := a + y * x;
The multiplication y*x is carried out first, then a is added to the
result of multiplication. This is because the multiplication operator
has higher level of priority than the adding operator.
Example 2
variable We1, We2, We3, Wy :
BIT := '1';
Wy := We1 and We2 xnor
We1 nor We3;
For the initial value of the variables We1, We2, We3 equal to '1',
the result is assigned to the variable Wy and is equal to '0'.
Example 3
variable Zm1: REAL := 100.0;
variable Zm2 : BIT_VECTOR(7 downto
0) := ('0','0','0','0','0','0','0','0');
variable Zm3, Zm4 :
BIT_VECTOR(1 to 0);
Zm1 /= 342.54  True
Zm1 = 100.0  True
Zm2 /= ('1', '0', '0', '0', '0', '0', '0', '0')  True
Zm3 = Zm4  True
Example 4
Zm1 > 42.54  True
Zm1 >= 100.0  True
Zm2 < ('1', '0', '0', '0', '0', '0', '0', '0')  True
Zm3 <= Zm2  True
Example 5
variable Zm5 : BIT_VECTOR(3 downto
0) := ('1','0','1','1');
Zm5 sll 1  ('0', '1', '1', '0')
Zm5 sll 3  ('1', '0', '0', '0')
Zm5 sll 3  Zm5 srl 3
Zm5 srl 1  ('0', '1', '0', '1')
Zm5 srl 3  ('0', '0', '0', '1')
Zm5 srl 3  Zm5 sll 3
Zm5 sla 1  ('0', '1', '1', '1')
Zm5 sla 3  ('1', '1', '1', '1')
Zm5 sla 3  Zm5 sra 3
Zm5 sra 1  ('1', '1', '0', '1')
Zm5 sra 3  ('1', '1', '1', '1')
Zm5 sra 3  Zm5 sla 3
Zm5 rol 1  ('0', '1', '1', '1')
Zm5 rol 3  ('1', '1', '0', '1')
Zm5 rol 3  Zm5 ror 3
Zm5 ror 1  ('1', '1', '0', '1')
Zm5 ror 3  ('0', '1', '1', '1')
Zm5 ror 3  Zm5 rol 3
Example 6
constant B1: BIT_VECTOR :=
"0000";  four element array
constant B2: BIT_VECTOR :=
"1111";  four element array
constant B3: BIT_VECTOR :=
B1 & B2;  eight element array, ascending
 direction, value "00001111"
subtype BIT_VECTOR_TAB is
BIT_VECTOR (1 downto 0);
constant B4: BIT_VECTOR_TAB
:= "01";
constant B5: BIT_VECTOR:= B4
& B2;  six element array, descending
 direction, value "011111"
constant B6 : BIT := '0' ;
constant B7 : BIT_VECTOR :=
B2 & B6; five element array, ascending
 direction, value "11110"
constant B8: BIT := '1';
constant B9: BIT_VECTOR :=
B6 & B8;  two element array, ascending
 direction value "01"
Example 7
z := x * ( y)  A legal expression
z := x / (not y)  A legal expression
The same expressions without parentheses would be illegal.
Example 7
variable A,B :Integer;
variable C : Real;
C:= 12.34 * ( 234.4 / 43.89 );
A:= B mod 2;
Example 8
2 ** 8 = 256
3.8 ** 3 = 54.872
4 ** (2) = 1 / (4**2) = 0.0625
Important Notes

All predefined operators for standard types are declared in the
package STANDARD.

The operator not is
classified as a miscellaneous operator only for the purpose of
defining precedence. Otherwise, it is classified as a logical operator.
