# Arithmetic Operators

**Visual Studio .NET 2003**

Arithmetic operators are used to perform many of the familiar arithmetic operations that involve the calculation of numeric values represented by literals, variables, other expressions, function and property calls, and constants.

## Arithmetic Operations

You can add two values in an expression together with the **+** operator, or subtract one from another with the **-** operator, as shown in the following examples:

Dim x As Integer x = 67 + 34 x = 32 - 12

Negation also uses the **-** operator, but with somewhat different syntax, as shown below:

Dim x As Integer = 65 Dim y As Integer y = -x

Multiplication and division use the ***** and **/** operators, respectively, as in these examples:

Dim y As Double y = 45 * 55.23 y = 32 / 23

Exponentiation uses the **^** operator, as shown below:

Dim z As Double z = 23 ^ 3 ' z equals the cube of 23.

Integer division is carried out using the **\** operator. Integer division returns the number of times one integer can evenly divide into another. Only integral types (**Byte**, **Short**, **Integer**, and **Long**) can be used with this operator. All other types must be converted to an integral type first. The following is an example of integer division:

Dim k As Integer k = 23 \ 5 ' k = 4

Modulus arithmetic is performed using the **Mod** operator. This operator returns the remainder after the divisor is divided into the dividend an integral number of times. If both divisor and dividend are integral types, the returned value is integral. If divisor and dividend are floating-point types, the returned value is a floating point variable. Two examples illustrate this behavior:

Dim x As integer = 100 Dim y As Integer = 6 Dim z As Integer z = x Mod y ' z equals 4. Dim a As Double = 100.3 Dim b As Double = 4.13 Dim c As Double c = a Mod b ' c equals 1.18.

### Division by Zero

Division by zero has different results depending on the data types involved. In integral divisions (**Short**, **Integer**, **Long**), a **System.DivideByZeroException** is thrown. In division operations on the **Decimal** or **Single** data type, Visual Basic also throws a **System.DivideByZeroException** exception. In floating-point divisions with the **Double** variable type, however, the result is the class member representing **NaN**, **PositiveInfinity**, or **NegativeInfinity**, depending on the dividend. The following table summarizes the various results of attempting to divide by zero.

Dividend data type | Divisor data type | Dividend value | Result |
---|---|---|---|

Double | Double | 0 | System.Double.NaN (not a number) |

Double | Double | > 0 | System.Double.PositiveInfinity |

Double | Double | < 0 | System.Double.NegativeInfinity |

When you catch a **System.DivideByZeroException** exception, you can use its members to help you handle it. The **HelpLink** property has a link to the appropriate help file, the **Message** property holds the message text for the exception, and the **StackTrace** property contains the trace, which should indicate where the error occurred. The **GetBaseException** method returns the original exception that caused this **DivideByZeroException**, as well as any other exceptions linked to it.

## Bitwise Operations

Bitwise operations evaluating two values in binary (base 2) form, compare the bits at corresponding positions, and then assign values based on the comparison, as in the demonstration below of bitwise **And**:

Dim x As Integer x = 3 And 5 ' x = 1

In this example, the value of `x `

is` `

Here's why:
`1`

.

- First, the values are converted to binary form, as shown below:
3 in binary form = 011

5 in binary form = 101

- Next, the binary representations are compared, one binary position at a time. If both bits at a given position are 1, then a 1 is placed in that position in the result. If either bit is 0, then a 0 is placed in that position in the result. In our example this works out as follows:
011 3 in binary form

101 5 in binary form

001 The result, in binary form

Converting back to decimal, 001 is the binary representation of 1, so x = 1.

The bitwise **Or** operation is similar, except that a 1 is assigned to the result bit if either of the compared bits is 1. **Xor** assigns a 1 to the result bit if only one of, but not both of, the compared bits is 1. **Not** takes a single operand and inverts all the bits, including the sign bit, and assigns that value to the result. This means that for positive numbers, **Not** always returns a negative. Likewise, for negative numbers, **Not** always returns a positive or zero.

NoteBitwise operations can be performed on integral types only. Floating point values must be converted to integral types before bitwise operation can proceed.

## Bit Shift Operations

A bit shift operation performs an arithmetic shift on a bit pattern. The pattern is contained in the operand on the left, while the operand on the right specifies the number of positions to shift the pattern. The data type of the pattern operand must be **Byte**, **Short**, **Integer**, or **Long**. The data type of the shift amount operand must be **Integer** or must widen to **Integer**.

Arithmetic shifts are not circular, which means the bits shifted off one end of the result are not reintroduced at the other end. The bit positions vacated by a shift are set as follows:

- Zero for an arithmetic left shift
- Zero for an arithmetic right shift of a positive number
- Zero for an arithmetic right shift of any pattern with data type
**Byte** - One for an arithmetic right shift of a negative number (
**Short**,**Integer**, or**Long**)

In the following example, an **Integer** value is shifted both left and right:

Dim Pattern As Integer = 12 ' Low-order bits are 0000 1100 Dim LResult, RResult As Integer LResult = Pattern << 3 ' Left shift of 3 bits produces value of 96 RResult = Pattern >> 2 ' Right shift of 2 bits produces value of 3

Arithmetic shifts never generate overflow exceptions.

## Type Safety

Operands should normally be of the same type. For example, if you are adding an **Integer **variable, you should add it to another **Integer** variable, and the variable that the value is assigned to should be of type **Integer** as well.

One way to ensure good type-safe coding practice is to use **Option Strict**. If **Option Strict **is** On,** Visual Basic .NET automatically performs type-safe conversions. Thus, if you try to add an **Integer** variable to a **Double** variable and assign the value to a **Double** variable, the operation proceeds normally. Unsafe, or narrowing conversions, on the other hand, cause a compiler error. Thus if you try to add an **Integer** variable to a **Double** variable and assign the value to an **Integer **variable, a compiler error results, because a **Double** variable cannot be implicitly converted to type **Integer**.

If **Option Strict** is **Off**, however, these implicit narrowing conversions are allowed to take place, but can result in the unexpected loss of data or precision. For this reason, it is recommended that you use **Option Strict On** when writing production code. For additional information about conversions, see Widening and Narrowing Conversions, and for information about **Option Strict**, see Option Strict Statement.

#### See Also

DivideByZeroException Class | Widening and Narrowing Conversions | Option Strict Statement | Arithmetic Operators | Bit Shift Operators