Math.DivRem Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: System.Runtime.Extensions.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Menghitung kuota dua angka dan juga mengembalikan sisanya dalam parameter output.

Overload

DivRem(Int64, Int64, Int64)	Menghitung kuota dua bilangan bulat bertanda tangan 64-bit dan juga mengembalikan sisanya dalam parameter output.
DivRem(Int32, Int32, Int32)	Menghitung kuota dua bilangan bulat bertanda tangan 32-bit dan juga mengembalikan sisanya dalam parameter output.
DivRem(UIntPtr, UIntPtr)	Menghasilkan kuota dan sisa dari dua angka ukuran asli yang tidak ditandatangani.
DivRem(UInt64, UInt64)	Menghasilkan kuota dan sisa dari dua angka 64-bit yang tidak ditandatangani.
DivRem(UInt32, UInt32)	Menghasilkan kuota dan sisa dari dua angka 32-bit yang tidak ditandatangani.
DivRem(UInt16, UInt16)	Menghasilkan kuota dan sisa dua angka 16-bit yang tidak ditandatangani.
DivRem(SByte, SByte)	Menghasilkan kuota dan sisa dari dua angka 8-bit yang ditandatangani.
DivRem(Int64, Int64)	Menghasilkan kuota dan sisa dua angka 64-bit yang ditandatangani.
DivRem(Int32, Int32)	Menghasilkan kuota dan sisa dua angka 32-bit yang ditandatangani.
DivRem(Int16, Int16)	Menghasilkan kuota dan sisa dua angka 16-bit yang ditandatangani.
DivRem(Byte, Byte)	Menghasilkan kuota dan sisa dua angka 8-bit yang tidak ditandatangani.
DivRem(IntPtr, IntPtr)	Menghasilkan kuota dan sisa dari dua angka ukuran asli yang ditandatangani.

DivRem(Int64, Int64, Int64)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghitung kuota dua bilangan bulat bertanda tangan 64-bit dan juga mengembalikan sisanya dalam parameter output.

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

Parameter

a: Int64

Pembagiannya.

b: Int64

Pembavis.

result: Int64

Ketika metode ini kembali, berisi sisanya.

Mengembalikan

Int64

Kuota dari angka yang ditentukan.

Pengecualian

DivideByZeroException

b nol.

Contoh

Contoh berikut menunjukkan metode DivRem(Int64, Int64, Int64).

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

Keterangan

Nilai yang tersisa sama dengan hasil operator sisa.

Lihat juga

IEEERemainder(Double, Double)

Berlaku untuk

DivRem(Int32, Int32, Int32)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghitung kuota dua bilangan bulat bertanda tangan 32-bit dan juga mengembalikan sisanya dalam parameter output.

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

Parameter

a: Int32

Pembagiannya.

b: Int32

Pembavis.

result: Int32

Ketika metode ini kembali, berisi sisanya.

Mengembalikan

Int32

Kuota dari angka yang ditentukan.

Pengecualian

DivideByZeroException

b nol.

Contoh

Contoh berikut menunjukkan metode DivRem(Int32, Int32, Int32).

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

Keterangan

Nilai yang tersisa sama dengan hasil operator sisa.

Lihat juga

IEEERemainder(Double, Double)

Berlaku untuk

DivRem(UIntPtr, UIntPtr)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Penting

API ini bukan kompatibel CLS.

Menghasilkan kuota dan sisa dari dua angka ukuran asli yang tidak ditandatangani.

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)

Parameter

left: UIntPtr
nuint

unativeint

Pembagiannya.

right: UIntPtr
nuint

unativeint

Pembavis.

Mengembalikan

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

Kuota dan sisa angka yang ditentukan.

Atribut: CLSCompliantAttribute

Berlaku untuk

DivRem(UInt64, UInt64)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Penting

API ini bukan kompatibel CLS.

Menghasilkan kuota dan sisa dari dua angka 64-bit yang tidak ditandatangani.

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)

Parameter

left: UInt64

Pembagiannya.

right: UInt64

Pembavis.

Mengembalikan

ValueTuple<UInt64,UInt64>

Kuota dan sisa angka yang ditentukan.

Atribut: CLSCompliantAttribute

Berlaku untuk

DivRem(UInt32, UInt32)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Penting

API ini bukan kompatibel CLS.

Menghasilkan kuota dan sisa dari dua angka 32-bit yang tidak ditandatangani.

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)

Parameter

left: UInt32

Pembagiannya.

right: UInt32

Pembavis.

Mengembalikan

ValueTuple<UInt32,UInt32>

Kuota dan sisa angka yang ditentukan.

Atribut: CLSCompliantAttribute

Berlaku untuk

DivRem(UInt16, UInt16)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Penting

API ini bukan kompatibel CLS.

Menghasilkan kuota dan sisa dua angka 16-bit yang tidak ditandatangani.

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)

Parameter

left: UInt16

Pembagiannya.

right: UInt16

Pembavis.

Mengembalikan

ValueTuple<UInt16,UInt16>

Kuota dan sisa angka yang ditentukan.

Atribut: CLSCompliantAttribute

Berlaku untuk

DivRem(SByte, SByte)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Penting

API ini bukan kompatibel CLS.

Menghasilkan kuota dan sisa dari dua angka 8-bit yang ditandatangani.

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)

Parameter

left: SByte

Pembagiannya.

right: SByte

Pembavis.

Mengembalikan

ValueTuple<SByte,SByte>

Kuota dan sisa angka yang ditentukan.

Atribut: CLSCompliantAttribute

Berlaku untuk

DivRem(Int64, Int64)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghasilkan kuota dan sisa dua angka 64-bit yang ditandatangani.

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)

Parameter

left: Int64

Pembagiannya.

right: Int64

Pembavis.

Mengembalikan

ValueTuple<Int64,Int64>

Kuota dan sisa angka yang ditentukan.

Berlaku untuk

DivRem(Int32, Int32)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghasilkan kuota dan sisa dua angka 32-bit yang ditandatangani.

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)

Parameter

left: Int32

Pembagiannya.

right: Int32

Pembavis.

Mengembalikan

ValueTuple<Int32,Int32>

Kuota dan sisa angka yang ditentukan.

Berlaku untuk

DivRem(Int16, Int16)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghasilkan kuota dan sisa dua angka 16-bit yang ditandatangani.

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)

Parameter

left: Int16

Pembagiannya.

right: Int16

Pembavis.

Mengembalikan

ValueTuple<Int16,Int16>

Kuota dan sisa angka yang ditentukan.

Berlaku untuk

DivRem(Byte, Byte)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghasilkan kuota dan sisa dua angka 8-bit yang tidak ditandatangani.

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)

Parameter

left: Byte

Pembagiannya.

right: Byte

Pembavis.

Mengembalikan

ValueTuple<Byte,Byte>

Kuota dan sisa angka yang ditentukan.

Berlaku untuk

DivRem(IntPtr, IntPtr)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Menghasilkan kuota dan sisa dari dua angka ukuran asli yang ditandatangani.

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)

Parameter

left: IntPtr
nint

nativeint

Pembagiannya.

right: IntPtr
nint

nativeint

Pembavis.

Mengembalikan

ValueTuple<IntPtr,IntPtr>

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

Kuota dan sisa angka yang ditentukan.

Berlaku untuk

Bagikan melalui

Math.DivRem Metode

Definisi

Overload

DivRem(Int64, Int64, Int64)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

DivRem(Int32, Int32, Int32)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

DivRem(UIntPtr, UIntPtr)

Parameter

Mengembalikan

Berlaku untuk

DivRem(UInt64, UInt64)

Parameter

Mengembalikan

Berlaku untuk

DivRem(UInt32, UInt32)

Parameter

Mengembalikan

Berlaku untuk

DivRem(UInt16, UInt16)

Parameter

Mengembalikan

Berlaku untuk

DivRem(SByte, SByte)

Parameter

Mengembalikan

Berlaku untuk

DivRem(Int64, Int64)

Parameter

Mengembalikan

Berlaku untuk

DivRem(Int32, Int32)

Parameter

Mengembalikan

Berlaku untuk

DivRem(Int16, Int16)

Parameter

Mengembalikan

Berlaku untuk

DivRem(Byte, Byte)

Parameter

Mengembalikan

Berlaku untuk

DivRem(IntPtr, IntPtr)

Parameter

Mengembalikan

Berlaku untuk

Sumber Daya Tambahan: