Math.DivRem Method

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

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

Overloads

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(UInt16, UInt16)	Produces the quotient and the remainder of two unsigned 16-bit numbers.
DivRem(SByte, SByte)	Produces the quotient and the remainder of two signed 8-bit numbers.
DivRem(Int64, Int64)	Produces the quotient and the remainder of two signed 64-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(IntPtr, IntPtr)	Produces the quotient and the remainder of two signed native-size numbers.

DivRem(Int64, Int64, Int64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

DivideByZeroException

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.

Applies to

DivRem(Int32, Int32, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

DivideByZeroException

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.

Applies to

DivRem(UIntPtr, UIntPtr)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: UIntPtr
nuint

unativeint

The dividend.

right: UIntPtr
nuint

unativeint

The divisor.

Returns

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

The quotient and the remainder of the specified numbers.

Attributes: CLSCompliantAttribute

Applies to

DivRem(UInt64, UInt64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: UInt64

The dividend.

right: UInt64

The divisor.

Returns

ValueTuple<UInt64,UInt64>

The quotient and the remainder of the specified numbers.

Attributes: CLSCompliantAttribute

Applies to

DivRem(UInt32, UInt32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: UInt32

The dividend.

right: UInt32

The divisor.

Returns

ValueTuple<UInt32,UInt32>

The quotient and the remainder of the specified numbers.

Attributes: CLSCompliantAttribute

Applies to

DivRem(UInt16, UInt16)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: UInt16

The dividend.

right: UInt16

The divisor.

Returns

ValueTuple<UInt16,UInt16>

The quotient and the remainder of the specified numbers.

Attributes: CLSCompliantAttribute

Applies to

DivRem(SByte, SByte)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: SByte

The dividend.

right: SByte

The divisor.

Returns

ValueTuple<SByte,SByte>

The quotient and the remainder of the specified numbers.

Attributes: CLSCompliantAttribute

Applies to

DivRem(Int64, Int64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: Int64

The dividend.

right: Int64

The divisor.

Returns

ValueTuple<Int64,Int64>

The quotient and the remainder of the specified numbers.

Applies to

DivRem(Int32, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: Int32

The dividend.

right: Int32

The divisor.

Returns

ValueTuple<Int32,Int32>

The quotient and the remainder of the specified numbers.

Applies to

DivRem(Int16, Int16)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: Int16

The dividend.

right: Int16

The divisor.

Returns

ValueTuple<Int16,Int16>

The quotient and the remainder of the specified numbers.

Applies to

DivRem(Byte, Byte)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: Byte

The dividend.

right: Byte

The divisor.

Returns

ValueTuple<Byte,Byte>

The quotient and the remainder of the specified numbers.

Applies to

DivRem(IntPtr, IntPtr)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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)

Parameters

left: IntPtr
nint

nativeint

The dividend.

right: IntPtr
nint

nativeint

The divisor.

Returns

ValueTuple<IntPtr,IntPtr>

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

The quotient and the remainder of the specified numbers.

Applies to

Share via

Math.DivRem Method

Definition

Overloads

DivRem(Int64, Int64, Int64)

Parameters

Returns

Exceptions

Examples

Remarks

See also

Applies to

DivRem(Int32, Int32, Int32)

Parameters

Returns

Exceptions

Examples

Remarks

See also

Applies to

DivRem(UIntPtr, UIntPtr)

Parameters

Returns

Applies to

DivRem(UInt64, UInt64)

Parameters

Returns

Applies to

DivRem(UInt32, UInt32)

Parameters

Returns

Applies to

DivRem(UInt16, UInt16)

Parameters

Returns

Applies to

DivRem(SByte, SByte)

Parameters

Returns

Applies to

DivRem(Int64, Int64)

Parameters

Returns

Applies to

DivRem(Int32, Int32)

Parameters

Returns

Applies to

DivRem(Int16, Int16)

Parameters

Returns

Applies to

DivRem(Byte, Byte)

Parameters

Returns

Applies to

DivRem(IntPtr, IntPtr)

Parameters

Returns

Applies to

Additional resources