# Beginners Guide to Arithmetic Operations on Korn Shell Variables

Place an integer expression in two pairs of parentheses ((…)) to invoke an Arithmetic evaluation. For readability, place a space before and after any arithmetic operator within the double pair of parentheses. The table below lists the standard arithmetic operations.

Operator Operation Example Result
+ Addition ((x = 24 + 25)) 49
- Subtraction ((x = 100 - 25)) 75
* Multiplication ((x = 4 * 5)) 20
/ Division ((x = 10 / 3)) 3
% Integer remainder ((x = 10 % 3)) 1

All arithmetic operations are performed using integer arithmetic, which can cause minor surprises:

``````\$ x=15.38
\$ y=15.72
\$ ((z = x + y))
\$ echo \$z
30
``````

Everything is integer arithmetic. Note what happens when division is performed in a calculation. For example, when computing the percentage of the eligible voters who actually voted, the following statement would most likely assign 0 to prct:

``````((prct = voted / eligible_voters * 100))
``````

The following algebraically equivalent statement is the correct way to compute the percentage of eligible voters in the Korn shell:

``````(((prct = voted * 100 / eligible_voters))
``````

## Arithmetic Precedence

• Expressions (operations) within parentheses are evaluated first. Use a single pair of parentheses around an expression to force it to be evaluated first.
• Multiplication (*) and division (% and /) have greater precedence than addition (+) and subtraction (-).
• Arithmetic expressions are evaluated from left to right.
• When there is the slightest doubt, use parentheses to force the evaluation order.

## Bit-wise Operations

The six bit-wise operators are listed in the table below:

Operator Operation Example Result
# base 2#1101010 or 16#6A 10#106
<< Shift bits left ((x = 2#11 << 3)) 2#11000
» Shift bits right ((x = 2#1001 » 2)) 2#10
& Bit-wise AND ((x = 2#101 & 2#110)) 2#100
Bit-wise OR ((x = 2#101
^ Bit-wise exclusive OR ((x = 2#101 ^ 2#110)) 2#11

The # operator designates the base of the value that follows it. For example, 2#101 means that the value 101 is a base 2 (binary) value (2#101 would be 5 in the decimal base).

The << operator performs a binary shift left by as many bits as are indicated by the number that follows the operator. The expression 2#10 << 1 yields the value 2#100. The expression 2#10100<< 2 yields the value 2#1010000. Vacated positions are padded with 0 or 1 based on whether the number is positive or negative, respectively. The » operator performs a binary shift right by as many bits as are indicated by the number that follows the operator. The expression 2#10 » 1 yields the value 2#1. The expression 2#10100 » 2 yields the value 2#101.

The & operator ANDs two binary numbers together. This means that the AND operation is performed on the corresponding digit of 0 or 1 in each number, resulting in a 1 if both digits are 1; otherwise, the result is 0. The | operator ORs two binary numbers together. This means that the OR operation is performed on the corresponding digit of 0 or 1 in each number, resulting in a 1 if either digit is a 1; otherwise, the result is 0. The ^ operator performs an exclusive OR on two binary numbers together. This means that an exclusive OR is performed on the corresponding digit of 0 or 1 in each number, resulting in 1 if only one of the digits is a 1. If both digits are 0 or both are 1, then the result is 0. 