 Pure Programmer # Operators

Every programming language provides built-in operators for performing arithmetic, logic and bitwise operations. You will also find operators to compare values and assign value to a variable, subscript arrays and invoke functions. Depending on the language you may find referencing/dereferencing, member selection, pattern matching, range or type casting operators. Many of these operators will be explored in this section, but some will be deferred until later sections where their use becomes necessary.

## Typecasting

In untyped languages like Perl we don't often need to convert a value of one type to a value of a different type. Often this is done automatically for us by the language. For example, converting an integer to a string or a string to an integer is done automatically based on the context.

One situation where we might need a typecast is when converting floating point values to an integer value. If we use the typecast to int we will get a truncation of the floating point value. Perhaps a better option is to use the floor() and ceil() math functions to either round down or round up as needed.

Ways to Convert Values
MethodDescription
i = int(fp)Truncate floating point
i = POSIX::trunc(fp)Round floating point toward zero
i = POSIX::ceil(fp)Round floating point up to integer
i = POSIX::floor(fp)Round floating point down to integer
i = POSIX::round(fp)Round floating point to nearest integer

## Arithmetic Operators

[[Arithmetic operations]] are one of the two major groups of operations that computers perform for us, the other being [[logical operations]]. Arithmetic operators include multiplication, division, remainder (modulus), addition, subtraction and negation (unary minus). Most of these operations should be familiar as they are the basic arithmetic operations taught in elementary school. Modulus is less familiar but it is simply the remainder after division. Remember those times studying long division where we ended up with a remainder? That remainder is the modulus.

The arithmetic operators are mostly similar to the symbols typically used in mathematics: addition (`+`), subtraction (`-`), division (`/`). Only multiplication (`*`) and modulus (`%`) differ from standard mathematical notation. Unlike standard mathematical notation where placing two symbols next to each other implies multiplication as in xyz (which means x × y × z), when writing code we must explicitly use the multiplication operator as in `x * y * z`.

```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = 3;
my \$b = 5;
my \$c = 2;
my \$d = 3.1415926;
my \$e = 4.0;

print "-b = ", (-\$b), "\n";
print "a + b = ", (\$a + \$b), "\n";
print "a + -b = ", (\$a + -\$b), "\n";
print "-a + b = ", (-\$a + \$b), "\n";
print "-a + -b = ", (-\$a + -\$b), "\n";
print "a - b = ", (\$a - \$b), "\n";
print "a - -b = ", (\$a - -\$b), "\n";
print "-a - b = ", (-\$a - \$b), "\n";
print "-a - -b = ", (-\$a - -\$b), "\n";
print "b * c = ", (\$b * \$c), "\n";
print "b * -c = ", (\$b * -\$c), "\n";
print "-b * c = ", (-\$b * \$c), "\n";
print "-b * -c = ", (-\$b * -\$c), "\n";
print "b / c = ", (\$b / \$c), "\n";
print "b / -c = ", (\$b / -\$c), "\n";
print "-b / c = ", (-\$b / \$c), "\n";
print "-b / -c = ", (-\$b / -\$c), "\n";
print "b // c = ", (int(\$b / \$c)), "\n";
print "b // -c = ", (int(\$b / -\$c)), "\n";
print "-b // c = ", (int(-\$b / \$c)), "\n";
print "-b // -c = ", (int(-\$b / -\$c)), "\n";
print "b \% a = ", (\$b % \$a), "\n";
print "b \% -a = ", (\$b % -\$a), "\n";
print "-b \% a = ", (-\$b % \$a), "\n";
print "-b \% -a = ", (-\$b % -\$a), "\n";
print "d + e = ", (\$d + \$e), "\n";
print "d - e = ", (\$d - \$e), "\n";
print "d * e = ", (\$d * \$e), "\n";
print "e / d = ", (\$e / \$d), "\n";
print "e // d = ", (int(\$e / \$d)), "\n";
}

```
Output
\$ perl Operators1.pl -b = -5 a + b = 8 a + -b = -2 -a + b = 2 -a + -b = -8 a - b = -2 a - -b = 8 -a - b = -8 -a - -b = 2 b * c = 10 b * -c = -10 -b * c = -10 -b * -c = 10 b / c = 2.5 b / -c = -2.5 -b / c = -2.5 -b / -c = 2.5 b // c = 2 b // -c = -2 -b // c = -2 -b // -c = 2 b % a = 2 b % -a = -1 -b % a = 1 -b % -a = -2 d + e = 7.1415926 d - e = -0.8584074 d * e = 12.5663704 e / d = 1.27323956645429 e // d = 1

## String Concatenation

String concatenation is a special operator that is used to combine two strings into a single string. We use the period (`.`) symbol to represent this special operation. For example:

```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = "Hello, ";
my \$b = "world";
my \$c = "Bruce";
my \$d = "Sheriff Brody";
my \$e = "!";
print \$a . \$b . \$e, "\n";
print \$a . \$c . \$e, "\n";
print \$a . \$d . \$e, "\n";
}

```
Output
\$ perl Operators2.pl Hello, world! Hello, Bruce! Hello, Sheriff Brody!

## Comparison Operators

The comparison operators less than, greater than, equal, not equal, etc. allow us to determine how two values compare to each other. They are fundamentally arithmetic in nature. This is because comparisons are subtraction operations that then look at whether the difference is negative, positive or zero.

The symbol to check equality is (`==`). Note that there are two equal signs not just one which has a different meaning, namely assignment. The symbol to check if two values are not equal is (`!=`). The symbols for less than (`<`) and greater than (`>`) are as we would expect. The symbols for less than or equal (`<=`) and greater than or equal (`>=`) add the equal sign to the less than or greater than symbols. For these symbols the equal sign always appears on the right.

```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = 3;
my \$b = 5;
my \$c = 3.1415926;
my \$d = 4.0;
my \$e = "apple";
my \$f = "pear";

print "a < b : ", (\$a < \$b), "\n";
print "a <= b : ", (\$a <= \$b), "\n";
print "a > b : ", (\$a > \$b), "\n";
print "a >= b : ", (\$a >= \$b), "\n";
print "a == b : ", (\$a == \$b), "\n";
print "a != b : ", (\$a != \$b), "\n";

print "c < d : ", (\$c < \$d), "\n";
print "c <= d : ", (\$c <= \$d), "\n";
print "c > d : ", (\$c > \$d), "\n";
print "c >= d : ", (\$c >= \$d), "\n";
print "c == d : ", (\$c == \$d), "\n";
print "c != d : ", (\$c != \$d), "\n";

print "e < f : ", (\$e lt \$f), "\n";
print "e <= f : ", (\$e le \$f), "\n";
print "e > f : ", (\$e gt \$f), "\n";
print "e >= f : ", (\$e ge \$f), "\n";
print "e == f : ", (\$e eq \$f), "\n";
print "e != f : ", (\$e ne \$f), "\n";
}

```
Output
\$ perl Operators3.pl a < b : 1 a <= b : 1 a > b : a >= b : a == b : a != b : 1 c < d : 1 c <= d : 1 c > d : c >= d : c == d : c != d : 1 e < f : 1 e <= f : 1 e > f : e >= f : e == f : e != f : 1

## Logical Operators

The logical operators allow us to perform [[Boolean]] arithmetic. We have the logical operators AND (&&), OR (||) and NOT (!) that can be used to form any logical expression needed. The logical operators operate on and return the values 0, '' or undef for falsity and anything that isn't false for truth.

ABA && B
0, '' or undef0, '' or undef0, '' or undef
0, '' or undefanything that isn't false0, '' or undef
anything that isn't false0, '' or undef0, '' or undef
anything that isn't falseanything that isn't falseanything that isn't false
Logical AND

ABA || B
0, '' or undef0, '' or undef0, '' or undef
0, '' or undefanything that isn't falseanything that isn't false
anything that isn't false0, '' or undefanything that isn't false
anything that isn't falseanything that isn't falseanything that isn't false
Logical OR

A! A
0, '' or undefanything that isn't false
anything that isn't false0, '' or undef
Logical NOT
```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = 1;
my \$b = 0;

print "a AND b : ", (\$a && \$b), "\n";
print "a OR b : ", (\$a || \$b), "\n";
print "NOT a : ", (!\$a), "\n";
print "NOT b : ", (!\$b), "\n";
}

```
Output
\$ perl Operators4.pl a AND b : 0 a OR b : 1 NOT a : NOT b : 1

## Bitwise Operators

We also have [[bitwise operators]] that work on the premise that each bit (0 or 1) in a value can be considered either 0, '' or undef or anything that isn't false, respectively. Bitwise operators operate on integer values and perform their operation for each pair of bits (for binary operations) in the value. Some examples using 4-bit values are illustrated below.

ABA & B
000000000000
000001010000
001101010001
110001010100
111100110011
111111111111
Bitwise AND

ABA | B
000000000000
000001010101
001101010111
110001011101
111100111111
111111111111
Bitwise OR

ABA ^ B
000000000000
000001010101
001101010110
110001011001
111100111100
111111110000
Bitwise XOR

A~A
00001111
00111100
10100101
11110000
Compliment
```#!/usr/bin/env perl
use utf8;
use Utils;
use strict;
use warnings;

MAIN:
{
my \$a = 0x5555AAAA;
my \$b = 0x036C36CF;

print Utils::messageFormat("Bitwise a AND b : \{0:08x\}", (Utils::bitwiseAnd32(\$a, \$b))), "\n";
print Utils::messageFormat("Bitwise a OR b : \{0:08x\}", (Utils::bitwiseOr32(\$a, \$b))), "\n";
print Utils::messageFormat("Bitwise a XOR b : \{0:08x\}", (Utils::bitwiseXOr32(\$a, \$b))), "\n";
print Utils::messageFormat("Compliment a : \{0:08x\}", (Utils::complement32(\$a))), "\n";
print Utils::messageFormat("Compliment b : \{0:08x\}", (Utils::complement32(\$b))), "\n";
}

```
Output
\$ perl Operators5.pl Bitwise a AND b : 0144228a Bitwise a OR b : 577dbeef Bitwise a XOR b : 56399c65 Compliment a : -5555aaab Compliment b : -36c36d0

## Increment and Decrement

The increment (`++`) and decrement (`--`)operators modify a variable by adding or subtracting one respectively. These unary operators can be applied in front of (prefix) or behind (postfix) the variable symbol. The prefix operators return the new value of the variable whereas the postfix form returns the original value of the variable. In this ways the increment and decrement operators can be used to modify a variable but also can also be used in expressions. It can be tricky to use them correctly so it is generally best to only use a variable once in an expression if it has increment or decrement applied to it.

## Assignment Operators

Assignment operators allow us to change the value of a variable. The assignment operator is represented by a single equal sign (`=`). It should not be confused with the equivalence comparison operator which is represented by a double equal sign (`==`). In addition to simple assignment we also have variations on the assignment operator that perform an operation before assignment. These shorthand assignment operators are listed below showing the equivalent using only simple assignment.

Assignment Operators
OperatorEquivalent
A *= BA = A * B
A /= BA = A / B
A %= BA = A % B
A += BA = A + B
A -= BA = A - B
A &= BA = A & B
A |= BA = A | B
A ^= BA = A ^ B
A <<= BA = A << B
A >>= BA = A >> B
```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = 3;

++\$a;
print "++a: ", \$a, "\n";
--\$a;
print "--a: ", \$a, "\n";

\$a += 2;
print "a += 2 : ", \$a, "\n";
\$a *= 3;
print "a *= 3 : ", \$a, "\n";
\$a -= 4;
print "a -= 4 : ", \$a, "\n";
\$a /= 5;
print "a /= 5 : ", \$a, "\n";
}

```
Output
\$ perl Operators6.pl ++a: 4 --a: 3 a += 2 : 5 a *= 3 : 15 a -= 4 : 11 a /= 5 : 2.2

## Conditional Operator

The only ternary operator (takes three operands) is the conditional operator. Based on the truth of the first operator, it will yield either the value of the second or third operator. The expression `A ? B : C` yields B if A is true and C if A is false.

```#!/usr/bin/env perl
use utf8;
use strict;
use warnings;

MAIN:
{
my \$a = 3;
my \$b = 5;

print "a < b ? -1 : 1 => ", (\$a < \$b ? -1 : 1), "\n";
print "b < a ? -1 : 1 => ", (\$b < \$a ? -1 : 1), "\n";
print "a < b ? 'less' : 'greater' => ", (\$a < \$b ? "less" : "greater"), "\n";
print "b < a ? 'less' : 'greater' => ", (\$b < \$a ? "less" : "greater"), "\n";
}

```
Output
\$ perl Operators7.pl a < b ? -1 : 1 => -1 b < a ? -1 : 1 => 1 a < b ? 'less' : 'greater' => less b < a ? 'less' : 'greater' => greater
```#!/usr/bin/env perl
use utf8;
use Utils;
use strict;
use warnings;

MAIN:
{
my \$sFloat = "3.1415926";
my \$sInt = "3";
my \$sLong = "123456789123456789";
my \$a = Utils::stodWithDefault(\$sFloat, 0.0);
my \$b = Utils::stoiWithDefault(\$sInt, 0);
my \$c = Utils::stoiWithDefault(\$sLong, 0);
my \$strA = \$a;
my \$strB = \$b;
my \$strC = \$c;

print Utils::messageFormat("sFloat as double: \{0:f\}", \$a), "\n";
print Utils::messageFormat("sInt as int: \{0:d\}", \$b), "\n";
print Utils::messageFormat("sLong as long: \{0:d\}", \$c), "\n";
print Utils::messageFormat("a as string: \{0:s\}", \$strA), "\n";
print Utils::messageFormat("b as string: \{0:s\}", \$strB), "\n";
print Utils::messageFormat("c as string: \{0:s\}", \$strC), "\n";
}

```
Output
\$ perl Operators8.pl sFloat as double: 3.141593 sInt as int: 3 sLong as long: 123456789123456789 a as string: 3.1415926 b as string: 3 c as string: 123456789123456789

## Precedence

For simple expressions that contain only one operator, it is easy to see how it will be evaluated. But more complex expressions that contain multiple operators could lead to ambiguity and unpredictable results unless we had some rules in place to help us out. These rules to eliminate ambiguity are the rules of precedence illustrated below. In this table, operators which have higher precedence appear closer to the top. Operators with lower precedence appear closer to the bottom. In a situation where two operators are potentially operating on a value, the operator that is higher in the table takes precedence over a lower operator. If the two operators are on the same level of precedence then the associativity of the operators helps us to determine which takes precedence.

For example, the expression `5 * 3 + 1` could be ambiguous. Without rules of precedence it wouldn't be clear weather the multiplication or the addition should be performed first. If the multiplication takes precedence we would have `(5 * 3) + 1 == 16` whereas if the addition takes precedence we would have `5 * (3 + 1) == 20`. But we do have rules of precedence so there is only one correct way to interpret that expression. Because multiplication appears in the table on a level above addition, we know that the first interpretation yielding 16 is the correct one. If we instead wanted the expression to be evaluated the second way to yield 20, we would have to use parenthesis to explicitly override the rules of precedence. Many of the rules of precedence come from standard arithmetic and logical notation so they should seem familiar.

Rules of precedence don't guarantee any particular order of evaluation, but they do help resolve issues when two operators are applied to the same value. This subtlty is not obvious because in most expressions there is only one order of evaluation that follows the rules of precedence. Consider `(10 - 6) - (3 - 1)`. At first glance it would appear that the parenthesis cause this expression to be evaluated in only one way. But it turns out that there are two ways to evaluate this expression without violating the rules of precedence, namely to compute `(10 - 6)` first or to compute `(3 - 1)` first. So there are two ways to order the evaluation of this expression without violating the rules of precedence. In this case as in most cases, the end result will be the same, but it illustrates that the rules of precedence still leave some leeway in how the computer carries out the evaluation of the expression.

Where we get into trouble is with the operators that change a variable, namely the increment (`++`), decrement (`--`) and assignment operators. When these operators are used in an expression, leeway in when that operation is performed can cause the entire expression to yield different results. Let us assume that we have a variable A that is set to 1. Then we consider the expression `++A - ++A`. According to the rules of precedence there is no ambiguity in this expression. The first A has a prefix increment (`++`) applied on the left and subtraction (`-`) on the right. Since unary operators take precedence over subtraction we know that the increment must be applied before the addition. The second A only has one operator applied, the prefix increment so that must be applied before its result is added to the result of the first A after it is incremented. So here is the problem, we need to know when the first A is incremented to know what value is represented by the second A. The computer is free to evalutate the first `++A` yielding 2 then the second `++A` yielding 3. Equally it is free to evaluate the second `++A` first yielding 2 then the first yielding 3. This would give us either `2 - 3` or `3 - 2` neither of which violate any of the rules of precedence. So in this case there is a reliance on knowing the order of evaluation which leads to ambiguity. Just because it evaluates one way doesn't mean that it will always evaluate that way. A new version of the language tools can cause the expression to change how it is evaluated leading to a difficult bug to track down. So to avoid this problem we have a rule of thumb to never use a variable more than once in an expression if it has had an operator applied that produces the side effect of changing that variable.

Consider the expression `10 * 6 - 4 / 2`. Two of the values have operators on both the left and the right side requiring us to use the rules of precedence. Two values do not. Use parenthesis to show how the rules of precedence require us to interpret this expression.
Answer: `((10 * 6) - (4 / 2)) == (60 - 2) == 58`
Note: It is equally correct for `(10 * 6)` to be evaluated first or for `(4 / 2)` to be evaluated first. Because the expressions do not have any side effects, the result will be the same either way.

Consider the expression `A + B << 2 * 3 & 0xff`. Two of the values have operators on both the left and the right side requiring us to use the rules of precedence. Two values do not. Use parenthesis to show how the rules of precedence require us to interpret this expression.
Answer: `(((A + B) << (2 * 3)) & 0xff)`

Perl Operator Rules of Precedence
Operator Description Associativity
`()`List operatorLeft-to-Right
`->`Infix dereference (arrow)Left-to-Right
`++` `--`prefix and postfix increment and decrementN/A
`**`ExponentiationRight-to-Left
`+` `-`Unary plus and minusRight-to-Left
`!` `~`Logical NOT and bitwise compliment
`\`Reference
`=~` `!~`Regular expression pattern matchingLeft-to-Right
`*` `/` `%` `x`Multiplication, division, remainder and timesLeft-to-Right
`+` `-`Addition and subtractionLeft-to-Right
`.`String concatenation
`<<` `>>`Bitwise arithmetic left and right shiftLeft-to-Right
`print` `chdir` etc.Named unary operatorsN/A
`<` `<=`Numerical comparison operators < and ≤N/A
`>` `>=`Numerical comparison operators > and ≥
`lt` `le`Stringwise comparison operators < and ≤
`gt` `ge`Stringwise comparison operators > and ≥
`==` `!=` `<=>`Numerical =, ≠ and compareN/A
`eq` `ne` `cmp`Stringwise =, ≠ and compareN/A
`~~`Smart matchN/A
`&`Bitwise ANDLeft-to-Right
`|` `^`Bitwise OR (inclusive OR) and XOR (exclusive OR)Left-to-Right
`&&`Logical ANDLeft-to-Right
`||` `//`Logical OR and logical defined-ORLeft-to-Right
`..` `...`RangeN/A
`?:`Ternary conditionalRight-to-Left
`=`Direct assignmentRight-to-Left
`*=` `/=` `%=`Assignment by product, quotient, and remainder
`+=` `-=`Assignment by sum and difference
`<<=` `>>=` `>>>=`Assignment by bitwise left shift and right shift
`&=` `^=` `|=`Assignment by bitwise AND, XOR, and OR
`,` `=>`CommaLeft-to-Right
`not`Logical NOTRight-to-Left
`and`Flow control ANDLeft-to-Right
`or` `xor`Flow control OR and XORLeft-to-Right

As we have seen, we can use parenthesis to change how an expression is to be interpreted. Using parenthesis can also make an expression easier to read. Adding parenthesis to an equation doesn't incur any performance penalty even if the expression would have been interpreted the desired way without the parenthesis.

TODO: Precision and rounding errors in operations 1/3

## Questions

• {{Write an expression that yields 4x2+3x+1.}}
• {{Write an expression that yields 5x3+2x2-x-3.}}
• {{Write an expression that yields the ratio of x+1 to x+3.}}
• Write an expression that yields 32x using a bit shift operator.
• Write an expression that yields x/16 using a bit shift operator.
• Write an expression that yields 1 if x is odd, 0 if x is even.
• Write an expression that yields true if the value in x is even.
• Write an expression that yields true if the value in x is odd.
• Write an expression that yields true if the value in x is a multiple of 7.
• Write an expression that yields 0 if x is a multiple of 10, otherwise yield 1.
• Write an expression that yields 0 if x is less than or equal to 4000, otherwise yield x-4000.
• Write an expression that yields true if the value of x is 326.
• Write an expression that yields true if the value of x is not 326.
• Write an expression that yields the integer part of a floating point value in x.
• Show that x ≤ 5 is equivalent to x - 5 ≤ 0. Show how all the comparison operators are equivalent to a subtract and a comparison to 0.
• Compute the value of the following expressions using the rules of precedence given above:
1. {{2 * 5 - 3}}
2. {{8 % 3 * 2}}
3. {{3 << 2 * 3}}
4. {{8 >> 1 + 1}}
5. {{8 / 2 - 1}}
6. {{5 + -2 - +1}}
7. {{4 - 2 * 5 - 2}}
8. {{(4 - 2) * 5 - 2}}
9. {{4 - 2 * (5 - 2)}}
10. {{(4 - 2) * (5 - 2)}}
11. {{4 - (2 * 5 - 2)}}
• {{Write an expression that is true if A or B is true but not both. (This is called exclusive OR)}}

## Projects

More ★'s indicate higher difficulty level.

## References

• [[Perl Language Reference]]
• [[Comprehensive Perl Archive Network (CPAN)]]
• [[Beginning Perl]], Simon Cozens
• [[Perl Monks Tutorials]]