Export (0) Print
Expand All

Math.DivRem Method

Note: This namespace, class, or member is supported only in version 1.1 of the .NET Framework.

Returns the quotient of two numbers, also passing the remainder as an output parameter.

Overload List

Returns the quotient of two 32-bit signed integers, also passing the remainder as an output parameter.

[Visual Basic] Overloads Public Shared Function DivRem(Integer, Integer, ByRef Integer) As Integer
[C#] public static int DivRem(int, int, int);
[C++] public: static int DivRem(int, int, int);
[JScript] public static function DivRem(int, int, int) : int;

Returns the quotient of two 64-bit signed integers, also passing the remainder as an output parameter.

[Visual Basic] Overloads Public Shared Function DivRem(Long, Long, ByRef Long) As Long
[C#] public static long DivRem(long, long, long);
[C++] public: static __int64 DivRem(__int64, __int64, __int64);
[JScript] public static function DivRem(long, long, long) : long;

Example

[Visual Basic, C#, C++] Note   This example shows how to use one of the overloaded versions of DivRem. For other examples that might be available, see the individual overload topics.
[Visual Basic] 
' This example demonstrates Math.DivRem()
'                           Math.IEEERemainder()
Imports System

Class Sample
   Public Shared Sub Main()
      Dim int1 As Integer = Int32.MaxValue
      Dim int2 As Integer = Int32.MaxValue
      Dim intResult As Integer
      Dim long1 As Long = Int64.MaxValue
      Dim long2 As Long = Int64.MaxValue
      Dim longResult As Long
      Dim doubleResult As Double
      Dim divisor As Double
      Dim nl As [String] = Environment.NewLine
      '
      Console.WriteLine("{0}Calculate the quotient and remainder of two Int32 values:", nl)
      intResult = Math.DivRem(int1, 2, int2)
      Console.WriteLine("{0}/{1} = {2}, with a remainder of {3}.", int1, 2, intResult, int2)
      '
      Console.WriteLine("{0}Calculate the quotient and remainder of two Int64 values:", nl)
      longResult = Math.DivRem(long1, 4, long2)
      Console.WriteLine("{0}/{1} = {2}, with a remainder of {3}.", long1, 4, longResult, long2)
      '
      Dim str1 As [String] = "The IEEE remainder of {0:e}/{1:f} is {2:e}"
      divisor = 2.0
      Console.WriteLine("{0}Divide two double-precision floating-point values:", nl)
      doubleResult = Math.IEEERemainder([Double].MaxValue, divisor)
      Console.Write("1) ")
      Console.WriteLine(str1, [Double].MaxValue, divisor, doubleResult)
      
      divisor = 3.0
      doubleResult = Math.IEEERemainder([Double].MaxValue, divisor)
      Console.Write("2) ")
      Console.WriteLine(str1, [Double].MaxValue, divisor, doubleResult)
      Console.WriteLine("Note that two positive numbers can yield a negative remainder.")
   End Sub 'Main
End Class 'Sample
'
'This example produces the following results:
'
'Calculate the quotient and remainder of two Int32 values:
'2147483647/2 = 1073741823, with a remainder of 1.
'
'Calculate the quotient and remainder of two Int64 values:
'9223372036854775807/4 = 2305843009213693951, with a remainder of 3.
'
'Divide two double-precision floating-point values:
'1) The IEEE remainder of 1.797693e+308/2.00 is 0.000000e+000
'2) The IEEE remainder of 1.797693e+308/3.00 is -1.995840e+292
'Note that two positive numbers can yield a negative remainder.
'

[C#] 
// This example demonstrates Math.DivRem()
//                           Math.IEEERemainder()
using System;

class Sample 
{
    public static void Main() 
    {
    int int1 = Int32.MaxValue;
    int int2 = Int32.MaxValue;
    int intResult;
    long long1 = Int64.MaxValue;
    long long2 = Int64.MaxValue;
    long longResult;
    double doubleResult;
    double divisor;
    String nl = Environment.NewLine;
//
    Console.WriteLine("{0}Calculate the quotient and remainder of two Int32 values:", nl);
    intResult = Math.DivRem(int1, 2, out int2);
    Console.WriteLine("{0}/{1} = {2}, with a remainder of {3}.", int1, 2, intResult, int2);
//
    Console.WriteLine("{0}Calculate the quotient and remainder of two Int64 values:", nl);
    longResult = Math.DivRem(long1, 4, out long2);
    Console.WriteLine("{0}/{1} = {2}, with a remainder of {3}.", long1, 4, longResult, long2);
//
    String str1 = "The IEEE remainder of {0:e}/{1:f} is {2:e}";
    divisor = 2.0;
    Console.WriteLine("{0}Divide two double-precision floating-point values:", nl);
    doubleResult = Math.IEEERemainder(Double.MaxValue, divisor);
    Console.Write("1) ");
    Console.WriteLine(str1, Double.MaxValue, divisor, doubleResult);

    divisor = 3.0;
    doubleResult = Math.IEEERemainder(Double.MaxValue, divisor);
    Console.Write("2) ");
    Console.WriteLine(str1, Double.MaxValue, divisor, doubleResult);
    Console.WriteLine("Note that two positive numbers can yield a negative remainder.");
    }
}
/*
This example produces the following results:

Calculate the quotient and remainder of two Int32 values:
2147483647/2 = 1073741823, with a remainder of 1.

Calculate the quotient and remainder of two Int64 values:
9223372036854775807/4 = 2305843009213693951, with a remainder of 3.

Divide two double-precision floating-point values:
1) The IEEE remainder of 1.797693e+308/2.00 is 0.000000e+000
2) The IEEE remainder of 1.797693e+308/3.00 is -1.995840e+292
Note that two positive numbers can yield a negative remainder.
*/

[C++] 
// This example demonstrates Math.DivRem()
//                           Math.IEEERemainder()
#using <mscorlib.dll>
using namespace System;

int main() 
{
    int int1 = Int32::MaxValue;
    int int2 = Int32::MaxValue;
    int intResult;
    Int64 long1 = Int64::MaxValue;
    Int64 long2 = Int64::MaxValue;
    Int64 longResult;
    double doubleResult;
    double divisor;
    String* nl = Environment::NewLine;
//
    Console::WriteLine(S"{0}Calculate the quotient and remainder of two Int32 values:", nl);
    intResult = Math::DivRem(int1, 2, &int2);
    Console::WriteLine(S"{0}/{1} = {2}, with a remainder of {3}.", __box(int1), __box(2), __box(intResult), __box(int2));
//
    Console::WriteLine(S"{0}Calculate the quotient and remainder of two Int64 values:", nl);
    longResult = Math::DivRem(long1, 4, &long2);
    Console::WriteLine(S"{0}/{1} = {2}, with a remainder of {3}.", __box(long1), __box(4), __box(longResult), __box(long2));
//
    String* str1 = S"The IEEE remainder of {0:e}/{1:f} is {2:e}";
    divisor = 2.0;
    Console::WriteLine(S"{0}Divide two double-precision floating-point values:", nl);
    doubleResult = Math::IEEERemainder(Double::MaxValue, divisor);
    Console::Write(S"1) ");
    Console::WriteLine(str1, __box(Double::MaxValue), __box(divisor), __box(doubleResult));

    divisor = 3.0;
    doubleResult = Math::IEEERemainder(Double::MaxValue, divisor);
    Console::Write(S"2) ");
    Console::WriteLine(str1, __box(Double::MaxValue), __box(divisor), __box(doubleResult));
    Console::WriteLine(S"Note that two positive numbers can yield a negative remainder.");
}
/*
This example produces the following results:

Calculate the quotient and remainder of two Int32 values:
2147483647/2 = 1073741823, with a remainder of 1.

Calculate the quotient and remainder of two Int64 values:
9223372036854775807/4 = 2305843009213693951, with a remainder of 3.

Divide two double-precision floating-point values:
1) The IEEE remainder of 1.797693e+308/2.00 is 0.000000e+000
2) The IEEE remainder of 1.797693e+308/3.00 is -1.995840e+292
Note that two positive numbers can yield a negative remainder.
*/

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

See Also

Math Class | Math Members | System Namespace

Show:
© 2014 Microsoft