This documentation is archived and is not being maintained.

Math.IEEERemainder Method

.NET Framework 1.1

Returns the remainder resulting from the division of a specified number by another specified number.

```[Visual Basic]
Public Shared Function IEEERemainder( _
ByVal x As Double, _
ByVal y As Double _
) As Double
[C#]
public static double IEEERemainder(
double x,
double y
);
[C++]
public: static double IEEERemainder(
double x,
double y
);
[JScript]
public static function IEEERemainder(
x : double,
y : double
) : double;```

x
A dividend.
y
A divisor.

Return Value

A number equal to x- (y Q), where Q is the quotient of x/ y rounded to the nearest integer (if x/ y falls halfway between two integers, the even integer is returned).

If x- (y Q) is zero, the value +0 is returned if x is positive, or -0 if x is negative.

If y = 0, NaN (Not-A-Number) is returned.

Remarks

This operation complies with the remainder operation defined in Section 5.1 of ANSI/IEEE Std 754-1985; IEEE Standard for Binary Floating-Point Arithmetic; Institute of Electrical and Electronics Engineers, Inc; 1985.

Example

```[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 in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework, Common Language Infrastructure (CLI) Standard