# Mod Operator (Visual Basic)

**Visual Studio 2015**

Updated: July 20, 2015

For the latest documentation on Visual Studio 2017, see Visual Studio 2017 Documentation.

Divides two numbers and returns only the remainder.

number1 Mod number2

`number1`

Required. Any numeric expression.

`number2`

Required. Any numeric expression.

All numeric types. This includes the unsigned and floating-point types and `Decimal`

.

The result is the remainder after `number1`

is divided by `number2`

. For example, the expression `14 Mod 4`

evaluates to 2.

If either `number1`

or `number2`

is a floating-point value, the floating-point remainder of the division is returned. The data type of the result is the smallest data type that can hold all possible values that result from division with the data types of `number1`

and `number2`

.

If `number1`

or `number2`

evaluates to Nothing, it is treated as zero.

Related operators include the following:

The \ Operator (Visual Basic) returns the integer quotient of a division. For example, the expression

`14 \ 4`

evaluates to 3.The / Operator (Visual Basic) returns the full quotient, including the remainder, as a floating-point number. For example, the expression

`14 / 4`

evaluates to 3.5.

If `number2`

evaluates to zero, the behavior of the `Mod`

operator depends on the data type of the operands. An integral division throws a DivideByZeroException exception. A floating-point division returns NaN.

The expression `a Mod b`

is equivalent to either of the following formulas:

`a - (b * (a \ b))`

`a - (b * Fix(a / b))`

When you work with floating-point numbers, remember that they do not always have a precise representation in memory. This could lead to unexpected results from certain operations, such as value comparison and the `Mod`

operator. For more information, see Troubleshooting Data Types.

The `Mod`

operator can be *overloaded*, which means that a class or structure can redefine its behavior. If your code applies `Mod`

to an instance of a class or structure that includes such an overload, be sure you understand its redefined behavior. For more information, see Operator Procedures.

The following example uses the `Mod`

operator to divide two numbers and return only the remainder. If either number is a floating-point number, the result is a floating-point number that represents the remainder.

Debug.WriteLine(10 Mod 5) ' Output: 0 Debug.WriteLine(10 Mod 3) ' Output: 1 Debug.WriteLine(-10 Mod 3) ' Output: -1 Debug.WriteLine(12 Mod 4.3) ' Output: 3.4 Debug.WriteLine(12.6 Mod 5) ' Output: 2.6 Debug.WriteLine(47.9 Mod 9.35) ' Output: 1.15

The following example demonstrates the potential imprecision of floating-point operands. In the first statement, the operands are `Double`

, and 0.2 is an infinitely repeating binary fraction with a stored value of 0.20000000000000001. In the second statement, the literal type character `D`

forces both operands to `Decimal`

, and 0.2 has a precise representation.

firstResult = 2.0 Mod 0.2 ' Double operation returns 0.2, not 0. secondResult = 2D Mod 0.2D ' Decimal operation returns 0.

Int

Fix

Arithmetic Operators

Operator Precedence in Visual Basic

Operators Listed by Functionality

Troubleshooting Data Types

Arithmetic Operators in Visual Basic

\ Operator (Visual Basic)