# Math.DivRem Method

## Definition

Calculates the quotient of two numbers and also returns the remainder in an output parameter.

 DivRem(IntPtr, IntPtr) Produces the quotient and the remainder of two signed native-size numbers. DivRem(Int64, Int64, Int64) Calculates the quotient of two 64-bit signed integers and also returns the remainder in an output parameter. DivRem(Int32, Int32, Int32) Calculates the quotient of two 32-bit signed integers and also returns the remainder in an output parameter. DivRem(UIntPtr, UIntPtr) Produces the quotient and the remainder of two unsigned native-size numbers. DivRem(UInt64, UInt64) Produces the quotient and the remainder of two unsigned 64-bit numbers. DivRem(UInt32, UInt32) Produces the quotient and the remainder of two unsigned 32-bit numbers. DivRem(Int64, Int64) Produces the quotient and the remainder of two signed 64-bit numbers. DivRem(SByte, SByte) Produces the quotient and the remainder of two signed 8-bit numbers. DivRem(Int32, Int32) Produces the quotient and the remainder of two signed 32-bit numbers. DivRem(Int16, Int16) Produces the quotient and the remainder of two signed 16-bit numbers. DivRem(Byte, Byte) Produces the quotient and the remainder of two unsigned 8-bit numbers. DivRem(UInt16, UInt16) Produces the quotient and the remainder of two unsigned 16-bit numbers.

## DivRem(IntPtr, IntPtr)

Produces the quotient and the remainder of two signed native-size numbers.

``````public:
static ValueTuple<IntPtr, IntPtr> DivRem(IntPtr left, IntPtr right);``````
``public static (nint Quotient, nint Remainder) DivRem (nint left, nint right);``
``public static (IntPtr Quotient, IntPtr Remainder) DivRem (IntPtr left, IntPtr right);``
``static member DivRem : nativeint * nativeint -> ValueTuple<nativeint, nativeint>``
``Public Shared Function DivRem (left As IntPtr, right As IntPtr) As ValueTuple(Of IntPtr, IntPtr)``

left

nint

nativeint

The dividend.

right

nint

nativeint

The divisor.

#### Returns

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

The quotient and the remainder of the specified numbers.

## DivRem(Int64, Int64, Int64)

Calculates the quotient of two 64-bit signed integers and also returns the remainder in an output parameter.

``````public:
static long DivRem(long a, long b, [Runtime::InteropServices::Out] long % result);``````
``public static long DivRem (long a, long b, out long result);``
``static member DivRem : int64 * int64 * int64 -> int64``
``Public Shared Function DivRem (a As Long, b As Long, ByRef result As Long) As Long``

#### Parameters

a
Int64

The dividend.

b
Int64

The divisor.

result
Int64

When this method returns, contains the remainder.

#### Returns

Int64

The quotient of the specified numbers.

#### Exceptions

`b` is zero.

### Examples

The following example demonstrates the DivRem(Int64, Int64, Int64) method.

``````using System;

public class Example
{
public static void Main()
{
// Define several positive and negative dividends.
long[] dividends = { Int64.MaxValue, 13952, 0, -14032,
Int64.MinValue };
// Define one positive and one negative divisor.
long[] divisors = { 2000, -2000 };

foreach (long divisor in divisors)
{
foreach (long dividend in dividends)
{
long remainder;
long quotient = Math.DivRem(dividend, divisor, out remainder);
Console.WriteLine(@"{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}",
dividend, divisor, quotient, remainder);
}
}
}
}
// The example displays the following output:
//    9,223,372,036,854,775,807 \ 2,000 = 4,611,686,018,427,387, remainder 1,807
//    13,952 \ 2,000 = 6, remainder 1,952
//    0 \ 2,000 = 0, remainder 0
//    -14,032 \ 2,000 = -7, remainder -32
//    -9,223,372,036,854,775,808 \ 2,000 = -4,611,686,018,427,387, remainder -1,808
//    9,223,372,036,854,775,807 \ -2,000 = -4,611,686,018,427,387, remainder 1,807
//    13,952 \ -2,000 = -6, remainder 1,952
//    0 \ -2,000 = 0, remainder 0
//    -14,032 \ -2,000 = 7, remainder -32
//    -9,223,372,036,854,775,808 \ -2,000 = 4,611,686,018,427,387, remainder -1,808
``````
``````open System

// Define several positive and negative dividends.
let dividends =
[ Int64.MaxValue; 13952; 0; -14032; Int64.MinValue ]
// Define one positive and one negative divisor.
let divisors = [ 2000; -2000 ]

for divisor in divisors do
for dividend in dividends do
let quotient, remainder = Math.DivRem(dividend, divisor)
printfn \$@"{dividend:N0} \ {divisor:N0} = {quotient:N0}, remainder {remainder:N0}"

// The example displays the following output:
//    9,223,372,036,854,775,807 \ 2,000 = 4,611,686,018,427,387, remainder 1,807
//    13,952 \ 2,000 = 6, remainder 1,952
//    0 \ 2,000 = 0, remainder 0
//    -14,032 \ 2,000 = -7, remainder -32
//    -9,223,372,036,854,775,808 \ 2,000 = -4,611,686,018,427,387, remainder -1,808
//    9,223,372,036,854,775,807 \ -2,000 = -4,611,686,018,427,387, remainder 1,807
//    13,952 \ -2,000 = -6, remainder 1,952
//    0 \ -2,000 = 0, remainder 0
//    -14,032 \ -2,000 = 7, remainder -32
//    -9,223,372,036,854,775,808 \ -2,000 = 4,611,686,018,427,387, remainder -1,808
``````
``````Module Example
Public Sub Main()
' Define several positive and negative dividends.
Dim dividends() As Long = { Int64.MaxValue, 13952, 0, -14032, _
Int64.MinValue }
' Define one positive and one negative divisor.
Dim divisors() As Long = { 2000, -2000 }

For Each divisor As Long In divisors
For Each dividend As Long In dividends
Dim remainder As Long
Dim quotient As Long = Math.DivRem(dividend, divisor, remainder)
Console.WriteLine("{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}", _
dividend, divisor, quotient, remainder)
Next
Next
End Sub
End Module
' The example displays the following output:
'    9,223,372,036,854,775,807 \ 2,000 = 4,611,686,018,427,387, remainder 1,807
'    13,952 \ 2,000 = 6, remainder 1,952
'    0 \ 2,000 = 0, remainder 0
'    -14,032 \ 2,000 = -7, remainder -32
'    -9,223,372,036,854,775,808 \ 2,000 = -4,611,686,018,427,387, remainder -1,808
'    9,223,372,036,854,775,807 \ -2,000 = -4,611,686,018,427,387, remainder 1,807
'    13,952 \ -2,000 = -6, remainder 1,952
'    0 \ -2,000 = 0, remainder 0
'    -14,032 \ -2,000 = 7, remainder -32
'    -9,223,372,036,854,775,808 \ -2,000 = 4,611,686,018,427,387, remainder -1,808
``````

### Remarks

The remainder value equals the result of the remainder operator.

## DivRem(Int32, Int32, Int32)

Calculates the quotient of two 32-bit signed integers and also returns the remainder in an output parameter.

``````public:
static int DivRem(int a, int b, [Runtime::InteropServices::Out] int % result);``````
``public static int DivRem (int a, int b, out int result);``
``static member DivRem : int * int * int -> int``
``Public Shared Function DivRem (a As Integer, b As Integer, ByRef result As Integer) As Integer``

#### Parameters

a
Int32

The dividend.

b
Int32

The divisor.

result
Int32

When this method returns, contains the remainder.

#### Returns

Int32

The quotient of the specified numbers.

#### Exceptions

`b` is zero.

### Examples

The following example demonstrates the DivRem(Int32, Int32, Int32) method.

``````using System;

public class Example
{
public static void Main()
{
// Define several positive and negative dividends.
int[] dividends = { Int32.MaxValue, 13952, 0, -14032,
Int32.MinValue };
// Define one positive and one negative divisor.
int[] divisors = { 2000, -2000 };

foreach (int divisor in divisors)
{
foreach (int dividend in dividends)
{
int remainder;
int quotient = Math.DivRem(dividend, divisor, out remainder);
Console.WriteLine(@"{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}",
dividend, divisor, quotient, remainder);
}
}
}
}
// The example displays the following output:
//       2,147,483,647 \ 2,000 = 1,073,741, remainder 1,647
//       13,952 \ 2,000 = 6, remainder 1,952
//       0 \ 2,000 = 0, remainder 0
//       -14,032 \ 2,000 = -7, remainder -32
//       -2,147,483,648 \ 2,000 = -1,073,741, remainder -1,648
//       2,147,483,647 \ -2,000 = -1,073,741, remainder 1,647
//       13,952 \ -2,000 = -6, remainder 1,952
//       0 \ -2,000 = 0, remainder 0
//       -14,032 \ -2,000 = 7, remainder -32
//       -2,147,483,648 \ -2,000 = 1,073,741, remainder -1,648
``````
``````open System

// Define several positive and negative dividends.
let dividends =
[ Int32.MaxValue; 13952; 0; -14032; Int32.MinValue ]
// Define one positive and one negative divisor.
let divisors = [ 2000; -2000 ]

for divisor in divisors do
for dividend in dividends do
let quotient, remainder = Math.DivRem(dividend, divisor)
printfn \$@"{dividend:N0} \ {divisor:N0} = {quotient:N0}, remainder {remainder:N0}"

// The example displays the following output:
//       2,147,483,647 \ 2,000 = 1,073,741, remainder 1,647
//       13,952 \ 2,000 = 6, remainder 1,952
//       0 \ 2,000 = 0, remainder 0
//       -14,032 \ 2,000 = -7, remainder -32
//       -2,147,483,648 \ 2,000 = -1,073,741, remainder -1,648
//       2,147,483,647 \ -2,000 = -1,073,741, remainder 1,647
//       13,952 \ -2,000 = -6, remainder 1,952
//       0 \ -2,000 = 0, remainder 0
//       -14,032 \ -2,000 = 7, remainder -32
//       -2,147,483,648 \ -2,000 = 1,073,741, remainder -1,648
``````
``````Module Example
Public Sub Main()
' Define several positive and negative dividends.
Dim dividends() As Integer = { Int32.MaxValue, 13952, 0, -14032, _
Int32.MinValue }
' Define one positive and one negative divisor.
Dim divisors() As Integer = { 2000, -2000 }

For Each divisor As Integer In divisors
For Each dividend As Integer In dividends
Dim remainder As Integer
Dim quotient As Integer = Math.DivRem(dividend, divisor, remainder)
Console.WriteLine("{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}", _
dividend, divisor, quotient, remainder)
Next
Next
End Sub
End Module
' The example displays the following output:
'       2,147,483,647 \ 2,000 = 1,073,741, remainder 1,647
'       13,952 \ 2,000 = 6, remainder 1,952
'       0 \ 2,000 = 0, remainder 0
'       -14,032 \ 2,000 = -7, remainder -32
'       -2,147,483,648 \ 2,000 = -1,073,741, remainder -1,648
'       2,147,483,647 \ -2,000 = -1,073,741, remainder 1,647
'       13,952 \ -2,000 = -6, remainder 1,952
'       0 \ -2,000 = 0, remainder 0
'       -14,032 \ -2,000 = 7, remainder -32
'       -2,147,483,648 \ -2,000 = 1,073,741, remainder -1,648
``````

### Remarks

The remainder value equals the result of the remainder operator.

## DivRem(UIntPtr, UIntPtr)

Important

This API is not CLS-compliant.

Produces the quotient and the remainder of two unsigned native-size numbers.

``````public:
static ValueTuple<UIntPtr, UIntPtr> DivRem(UIntPtr left, UIntPtr right);``````
``````[System.CLSCompliant(false)]
public static (nuint Quotient, nuint Remainder) DivRem (nuint left, nuint right);``````
``````[System.CLSCompliant(false)]
public static (UIntPtr Quotient, UIntPtr Remainder) DivRem (UIntPtr left, UIntPtr right);``````
``````[<System.CLSCompliant(false)>]
static member DivRem : unativeint * unativeint -> ValueTuple<unativeint, unativeint>``````
``Public Shared Function DivRem (left As UIntPtr, right As UIntPtr) As ValueTuple(Of UIntPtr, UIntPtr)``

left

nuint

unativeint

The dividend.

right

nuint

unativeint

The divisor.

#### Returns

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

The quotient and the remainder of the specified numbers.

Attributes

## DivRem(UInt64, UInt64)

Important

This API is not CLS-compliant.

Produces the quotient and the remainder of two unsigned 64-bit numbers.

``````public:
static ValueTuple<System::UInt64, System::UInt64> DivRem(System::UInt64 left, System::UInt64 right);``````
``````[System.CLSCompliant(false)]
public static (ulong Quotient, ulong Remainder) DivRem (ulong left, ulong right);``````
``````[<System.CLSCompliant(false)>]
static member DivRem : uint64 * uint64 -> ValueTuple<uint64, uint64>``````
``Public Shared Function DivRem (left As ULong, right As ULong) As ValueTuple(Of ULong, ULong)``

left
UInt64

The dividend.

right
UInt64

The divisor.

#### Returns

ValueTuple<UInt64,UInt64>

The quotient and the remainder of the specified numbers.

Attributes

## DivRem(UInt32, UInt32)

Important

This API is not CLS-compliant.

Produces the quotient and the remainder of two unsigned 32-bit numbers.

``````public:
static ValueTuple<System::UInt32, System::UInt32> DivRem(System::UInt32 left, System::UInt32 right);``````
``````[System.CLSCompliant(false)]
public static (uint Quotient, uint Remainder) DivRem (uint left, uint right);``````
``````[<System.CLSCompliant(false)>]
static member DivRem : uint32 * uint32 -> ValueTuple<uint32, uint32>``````
``Public Shared Function DivRem (left As UInteger, right As UInteger) As ValueTuple(Of UInteger, UInteger)``

left
UInt32

The dividend.

right
UInt32

The divisor.

#### Returns

ValueTuple<UInt32,UInt32>

The quotient and the remainder of the specified numbers.

Attributes

## DivRem(Int64, Int64)

Produces the quotient and the remainder of two signed 64-bit numbers.

``````public:
static ValueTuple<long, long> DivRem(long left, long right);``````
``public static (long Quotient, long Remainder) DivRem (long left, long right);``
``static member DivRem : int64 * int64 -> ValueTuple<int64, int64>``
``Public Shared Function DivRem (left As Long, right As Long) As ValueTuple(Of Long, Long)``

left
Int64

The dividend.

right
Int64

The divisor.

#### Returns

ValueTuple<Int64,Int64>

The quotient and the remainder of the specified numbers.

## DivRem(SByte, SByte)

Important

This API is not CLS-compliant.

Produces the quotient and the remainder of two signed 8-bit numbers.

``````public:
static ValueTuple<System::SByte, System::SByte> DivRem(System::SByte left, System::SByte right);``````
``````[System.CLSCompliant(false)]
public static (sbyte Quotient, sbyte Remainder) DivRem (sbyte left, sbyte right);``````
``````[<System.CLSCompliant(false)>]
static member DivRem : sbyte * sbyte -> ValueTuple<sbyte, sbyte>``````
``Public Shared Function DivRem (left As SByte, right As SByte) As ValueTuple(Of SByte, SByte)``

left
SByte

The dividend.

right
SByte

The divisor.

#### Returns

ValueTuple<SByte,SByte>

The quotient and the remainder of the specified numbers.

Attributes

## DivRem(Int32, Int32)

Produces the quotient and the remainder of two signed 32-bit numbers.

``````public:
static ValueTuple<int, int> DivRem(int left, int right);``````
``public static (int Quotient, int Remainder) DivRem (int left, int right);``
``static member DivRem : int * int -> ValueTuple<int, int>``
``Public Shared Function DivRem (left As Integer, right As Integer) As ValueTuple(Of Integer, Integer)``

left
Int32

The dividend.

right
Int32

The divisor.

#### Returns

ValueTuple<Int32,Int32>

The quotient and the remainder of the specified numbers.

## DivRem(Int16, Int16)

Produces the quotient and the remainder of two signed 16-bit numbers.

``````public:
static ValueTuple<short, short> DivRem(short left, short right);``````
``public static (short Quotient, short Remainder) DivRem (short left, short right);``
``static member DivRem : int16 * int16 -> ValueTuple<int16, int16>``
``Public Shared Function DivRem (left As Short, right As Short) As ValueTuple(Of Short, Short)``

left
Int16

The dividend.

right
Int16

The divisor.

#### Returns

ValueTuple<Int16,Int16>

The quotient and the remainder of the specified numbers.

## DivRem(Byte, Byte)

Produces the quotient and the remainder of two unsigned 8-bit numbers.

``````public:
static ValueTuple<System::Byte, System::Byte> DivRem(System::Byte left, System::Byte right);``````
``public static (byte Quotient, byte Remainder) DivRem (byte left, byte right);``
``static member DivRem : byte * byte -> ValueTuple<byte, byte>``
``Public Shared Function DivRem (left As Byte, right As Byte) As ValueTuple(Of Byte, Byte)``

left
Byte

The dividend.

right
Byte

The divisor.

#### Returns

ValueTuple<Byte,Byte>

The quotient and the remainder of the specified numbers.

## DivRem(UInt16, UInt16)

Important

This API is not CLS-compliant.

Produces the quotient and the remainder of two unsigned 16-bit numbers.

``````public:
static ValueTuple<System::UInt16, System::UInt16> DivRem(System::UInt16 left, System::UInt16 right);``````
``````[System.CLSCompliant(false)]
public static (ushort Quotient, ushort Remainder) DivRem (ushort left, ushort right);``````
``````[<System.CLSCompliant(false)>]
static member DivRem : uint16 * uint16 -> ValueTuple<uint16, uint16>``````
``Public Shared Function DivRem (left As UShort, right As UShort) As ValueTuple(Of UShort, UShort)``

left
UInt16

The dividend.

right
UInt16

The divisor.

#### Returns

ValueTuple<UInt16,UInt16>

The quotient and the remainder of the specified numbers.

Attributes