Math.DivRem Methode

Definitie

Naamruimte:: System

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Berekent het quotiënt van twee getallen en retourneert ook de rest in een uitvoerparameter.

Overloads

Name	Description
DivRem(Int64, Int64, Int64)	Berekent het quotiënt van twee 64-bits ondertekende gehele getallen en retourneert ook de rest in een uitvoerparameter.
DivRem(Int32, Int32, Int32)	Berekent het quotiënt van twee 32-bits ondertekende gehele getallen en retourneert ook de rest in een uitvoerparameter.
DivRem(UIntPtr, UIntPtr)	Produceert het quotiënt en de rest van twee niet-ondertekende systeemeigen groottenummers.
DivRem(UInt64, UInt64)	Produceert het quotiënt en de rest van twee niet-ondertekende 64-bits getallen.
DivRem(UInt32, UInt32)	Produceert het quotiënt en de rest van twee niet-ondertekende 32-bits getallen.
DivRem(UInt16, UInt16)	Produceert het quotiënt en de rest van twee niet-ondertekende 16-bits getallen.
DivRem(SByte, SByte)	Produceert het quotiënt en de rest van twee ondertekende 8-bits getallen.
DivRem(Int64, Int64)	Produceert het quotiënt en de rest van twee ondertekende 64-bits getallen.
DivRem(Int32, Int32)	Produceert het quotiënt en de rest van twee ondertekende 32-bits getallen.
DivRem(Int16, Int16)	Produceert het quotiënt en de rest van twee ondertekende 16-bits getallen.
DivRem(Byte, Byte)	Produceert het quotiënt en de rest van twee niet-ondertekende 8-bits getallen.
DivRem(IntPtr, IntPtr)	Produceert het quotiënt en de rest van twee ondertekende systeemeigen groottenummers.

DivRem(Int64, Int64, Int64)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Berekent het quotiënt van twee 64-bits ondertekende gehele getallen en retourneert ook de rest in een uitvoerparameter.

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

Het dividend.

b: Int64

De deler.

result: Int64

Wanneer deze methode wordt geretourneerd, bevat u de rest.

Retouren

Int64

Het quotiënt van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

b is nul.

OverflowException

a is Int64.MinValue en b is -1.

Voorbeelden

In het volgende voorbeeld ziet u de DivRem(Int64, Int64, Int64) methode.

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

Opmerkingen

De restwaarde is gelijk aan het resultaat van de restoperator.

Zie ook

IEEERemainder(Double, Double)

Van toepassing op

DivRem(Int32, Int32, Int32)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Berekent het quotiënt van twee 32-bits ondertekende gehele getallen en retourneert ook de rest in een uitvoerparameter.

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

Het dividend.

b: Int32

De deler.

result: Int32

Wanneer deze methode wordt geretourneerd, bevat u de rest.

Retouren

Int32

Het quotiënt van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

b is nul.

OverflowException

a is Int32.MinValue en b is -1.

Voorbeelden

In het volgende voorbeeld ziet u de DivRem(Int32, Int32, Int32) methode.

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

Opmerkingen

De restwaarde is gelijk aan het resultaat van de restoperator.

Zie ook

IEEERemainder(Double, Double)

Van toepassing op

DivRem(UIntPtr, UIntPtr)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Belangrijk

Deze API is niet CLS-conform.

Produceert het quotiënt en de rest van twee niet-ondertekende systeemeigen groottenummers.

public:
 static ValueTuple<UIntPtr, UIntPtr> DivRem(UIntPtr left, UIntPtr right);

[System.CLSCompliant(false)]
public static(UIntPtr Quotient, UIntPtr Remainder) DivRem(UIntPtr left, UIntPtr right);

[System.CLSCompliant(false)]
public static(nuint Quotient, nuint Remainder) DivRem(nuint left, nuint 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

Het dividend.

right: UIntPtr
nuint

unativeint

De deler.

Retouren

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<unativeint,unativeint>

Het quotiënt en de rest van de opgegeven getallen.

Kenmerken: CLSCompliantAttribute

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(UInt64, UInt64)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Belangrijk

Deze API is niet CLS-conform.

Produceert het quotiënt en de rest van twee niet-ondertekende 64-bits getallen.

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

Het dividend.

right: UInt64

De deler.

Retouren

ValueTuple<UInt64,UInt64>

Het quotiënt en de rest van de opgegeven getallen.

Kenmerken: CLSCompliantAttribute

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(UInt32, UInt32)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Belangrijk

Deze API is niet CLS-conform.

Produceert het quotiënt en de rest van twee niet-ondertekende 32-bits getallen.

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

Het dividend.

right: UInt32

De deler.

Retouren

ValueTuple<UInt32,UInt32>

Het quotiënt en de rest van de opgegeven getallen.

Kenmerken: CLSCompliantAttribute

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(UInt16, UInt16)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Belangrijk

Deze API is niet CLS-conform.

Produceert het quotiënt en de rest van twee niet-ondertekende 16-bits getallen.

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

Het dividend.

right: UInt16

De deler.

Retouren

ValueTuple<UInt16,UInt16>

Het quotiënt en de rest van de opgegeven getallen.

Kenmerken: CLSCompliantAttribute

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(SByte, SByte)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Belangrijk

Deze API is niet CLS-conform.

Produceert het quotiënt en de rest van twee ondertekende 8-bits getallen.

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

Het dividend.

right: SByte

De deler.

Retouren

ValueTuple<SByte,SByte>

Het quotiënt en de rest van de opgegeven getallen.

Kenmerken: CLSCompliantAttribute

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(Int64, Int64)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Produceert het quotiënt en de rest van twee ondertekende 64-bits getallen.

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

Het dividend.

right: Int64

De deler.

Retouren

ValueTuple<Int64,Int64>

Het quotiënt en de rest van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

right is nul.

OverflowException

left is Int64.MinValue en right is -1.

Van toepassing op

DivRem(Int32, Int32)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Produceert het quotiënt en de rest van twee ondertekende 32-bits getallen.

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

Het dividend.

right: Int32

De deler.

Retouren

ValueTuple<Int32,Int32>

Het quotiënt en de rest van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

right is nul.

OverflowException

left is Int32.MinValue en right is -1.

Van toepassing op

DivRem(Int16, Int16)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Produceert het quotiënt en de rest van twee ondertekende 16-bits getallen.

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

Het dividend.

right: Int16

De deler.

Retouren

ValueTuple<Int16,Int16>

Het quotiënt en de rest van de opgegeven getallen.

Van toepassing op

DivRem(Byte, Byte)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Produceert het quotiënt en de rest van twee niet-ondertekende 8-bits getallen.

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

Het dividend.

right: Byte

De deler.

Retouren

ValueTuple<Byte,Byte>

Het quotiënt en de rest van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

right is nul.

Van toepassing op

DivRem(IntPtr, IntPtr)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Produceert het quotiënt en de rest van twee ondertekende systeemeigen groottenummers.

public:
 static ValueTuple<IntPtr, IntPtr> DivRem(IntPtr left, IntPtr right);

public static(IntPtr Quotient, IntPtr Remainder) DivRem(IntPtr left, IntPtr right);

public static(nint Quotient, nint Remainder) DivRem(nint left, nint 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

Het dividend.

right: IntPtr
nint

nativeint

De deler.

Retouren

ValueTuple<IntPtr,IntPtr>

ValueTuple<nativeint,nativeint>

Het quotiënt en de rest van de opgegeven getallen.

Uitzonderingen

DivideByZeroException

right is nul.

OverflowException

left is IntPtr.MinValue en right is -1.

Van toepassing op

Feedback

Is deze pagina nuttig?