Remainder after division (modulo operation)

Find the remainder after division for a vector of integers and the divisor `3`

.

a = 1:5; m = 3; b = mod(a,m)

`b = `*1×5*
1 2 0 1 2

Find the remainder after division for a set of integers including both positive and negative values. Note that nonzero results are always positive if the divisor is positive.

a = [-4 -1 7 9]; m = 3; b = mod(a,m)

`b = `*1×4*
2 2 1 0

Find the remainder after division by a negative divisor for a set of integers including both positive and negative values. Note that nonzero results are always negative if the divisor is negative.

a = [-4 -1 7 9]; m = -3; b = mod(a,m)

`b = `*1×4*
-1 -1 -2 0

Find the remainder after division for several angles using a modulus of `2*pi`

. Note that `mod`

attempts to compensate for floating-point round-off effects to produce exact integer results when possible.

theta = [0.0 3.5 5.9 6.2 9.0 4*pi]; m = 2*pi; b = mod(theta,m)

`b = `*1×6*
0 3.5000 5.9000 6.2000 2.7168 0

`a`

— Dividendscalar | vector | matrix | multidimensional array

Dividend, specified as a scalar, vector, matrix, or multidimensional
array. `a`

must be a real-valued array of any numerical
type. Numeric inputs `a`

and `m`

must
either be the same size or have sizes that are compatible (for example, `a`

is
an `M`

-by-`N`

matrix and `m`

is
a scalar or `1`

-by-`N`

row vector).
For more information, see Compatible Array Sizes for Basic Operations.

If `a`

and `m`

are duration
arrays, then they must be the same size unless one is a scalar. If
one input is a duration array, the other input can be a duration array
or a numeric array. In this context, `mod`

treats
numeric values as a number of standard 24-hour days.

If one input has an integer data type, then the other input
must be of the same integer data type or be a scalar `double`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `logical`

| `duration`

| `char`

`m`

— Divisorscalar | vector | matrix | multidimensional array

Divisor, specified as a scalar, vector, matrix, or multidimensional
array. `m`

must be a real-valued array of any numerical
type. Numeric inputs `a`

and `m`

must
either be the same size or have sizes that are compatible (for example, `a`

is
an `M`

-by-`N`

matrix and `m`

is
a scalar or `1`

-by-`N`

row vector).
For more information, see Compatible Array Sizes for Basic Operations.

If `a`

and `m`

are duration
arrays, then they must be the same size unless one is a scalar. If
one input is a duration array, the other input can be a duration array
or a numeric array. In this context, `mod`

treats
numeric values as a number of standard 24-hour days.

If one input has an integer data type, then the other input
must be of the same integer data type or be a scalar `double`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `logical`

| `duration`

| `char`

The concept of remainder after division is
not uniquely defined, and the two functions `mod`

and `rem`

each
compute a different variation. The `mod`

function
produces a result that is either zero or has the same sign as the
divisor. The `rem`

function produces a result that
is either zero or has the same sign as the dividend.

Another difference is the convention when the divisor is zero.
The `mod`

function follows the convention that `mod(a,0)`

returns `a`

,
whereas the `rem`

function follows the convention
that `rem(a,0)`

returns `NaN`

.

Both variants have their uses. For example, in signal processing,
the `mod`

function is useful in the context of
periodic signals because its output is periodic (with period equal
to the divisor).

The `mod`

function is useful
for congruence relationships: `a`

and `b`

are
congruent (mod m) if and only if `mod(a,m) == mod(b,m)`

.
For example, 23 and 13 are congruent (mod 5).

[1] Knuth, Donald E. *The Art of Computer Programming*.
Vol. 1. Addison Wesley, 1997 pp.39–40.

Calculate with arrays that have more rows than fit in memory.

This function fully supports tall arrays. For more information, see Tall Arrays.

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Arithmetic is performed using the output class. Results might not match MATLAB

^{®}due to differences in rounding errors.If one of the inputs has type

`int64`

or`uint64`

, both inputs must have the same type.

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Usage notes and limitations:

64-bit integers are not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

A modified version of this example exists on your system. Do you want to open this version instead?

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

- América Latina (Español)
- Canada (English)
- United States (English)

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)