Math.DivRem Metod

Definition

Namnområde:: System

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.Extensions.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Beräknar kvoten för två tal och returnerar även resten i en utdataparameter.

Överlagringar

Name	Description
DivRem(Int64, Int64, Int64)	Beräknar kvoten för två 64-bitars signerade heltal och returnerar även resten i en utdataparameter.
DivRem(Int32, Int32, Int32)	Beräknar kvoten för två 32-bitars signerade heltal och returnerar även resten i en utdataparameter.
DivRem(UIntPtr, UIntPtr)	Genererar kvoten och resten av två osignerade interna tal.
DivRem(UInt64, UInt64)	Genererar kvoten och resten av två osignerade 64-bitarsnummer.
DivRem(UInt32, UInt32)	Genererar kvoten och resten av två osignerade 32-bitarsnummer.
DivRem(UInt16, UInt16)	Genererar kvoten och resten av två osignerade 16-bitars tal.
DivRem(SByte, SByte)	Genererar kvoten och resten av två signerade 8-bitarsnummer.
DivRem(Int64, Int64)	Genererar kvoten och resten av två signerade 64-bitarsnummer.
DivRem(Int32, Int32)	Genererar kvoten och resten av två signerade 32-bitarsnummer.
DivRem(Int16, Int16)	Genererar kvoten och resten av två signerade 16-bitarsnummer.
DivRem(Byte, Byte)	Genererar kvoten och resten av två osignerade 8-bitars tal.
DivRem(IntPtr, IntPtr)	Genererar kvoten och resten av två signerade interna tal.

DivRem(Int64, Int64, Int64)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Beräknar kvoten för två 64-bitars signerade heltal och returnerar även resten i en utdataparameter.

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

Parametrar

a: Int64

Utdelningen.

b: Int64

Divisorn.

result: Int64

När den här metoden returnerar innehåller resten.

Returer

Int64

Kvoten för de angivna talen.

Undantag

DivideByZeroException

b är noll.

OverflowException

a är Int64.MinValue och b är -1.

Exempel

I följande exempel visas DivRem(Int64, Int64, Int64) metoden.

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

Kommentarer

Restvärdet är lika med resultatet av restoperatorn.

Se även

IEEERemainder(Double, Double)

Gäller för

DivRem(Int32, Int32, Int32)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Beräknar kvoten för två 32-bitars signerade heltal och returnerar även resten i en utdataparameter.

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

Parametrar

a: Int32

Utdelningen.

b: Int32

Divisorn.

result: Int32

När den här metoden returnerar innehåller resten.

Returer

Int32

Kvoten för de angivna talen.

Undantag

DivideByZeroException

b är noll.

OverflowException

a är Int32.MinValue och b är -1.

Exempel

I följande exempel visas DivRem(Int32, Int32, Int32) metoden.

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

Kommentarer

Restvärdet är lika med resultatet av restoperatorn.

Se även

IEEERemainder(Double, Double)

Gäller för

DivRem(UIntPtr, UIntPtr)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Viktigt!

Detta API uppfyller inte CLS.

Genererar kvoten och resten av två osignerade interna tal.

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)

Parametrar

left: UIntPtr
nuint

unativeint

Utdelningen.

right: UIntPtr
nuint

unativeint

Divisorn.

Returer

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<unativeint,unativeint>

Kvoten och resten av de angivna talen.

Attribut: CLSCompliantAttribute

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(UInt64, UInt64)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Viktigt!

Detta API uppfyller inte CLS.

Genererar kvoten och resten av två osignerade 64-bitarsnummer.

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)

Parametrar

left: UInt64

Utdelningen.

right: UInt64

Divisorn.

Returer

ValueTuple<UInt64,UInt64>

Kvoten och resten av de angivna talen.

Attribut: CLSCompliantAttribute

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(UInt32, UInt32)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Viktigt!

Detta API uppfyller inte CLS.

Genererar kvoten och resten av två osignerade 32-bitarsnummer.

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)

Parametrar

left: UInt32

Utdelningen.

right: UInt32

Divisorn.

Returer

ValueTuple<UInt32,UInt32>

Kvoten och resten av de angivna talen.

Attribut: CLSCompliantAttribute

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(UInt16, UInt16)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Viktigt!

Detta API uppfyller inte CLS.

Genererar kvoten och resten av två osignerade 16-bitars tal.

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)

Parametrar

left: UInt16

Utdelningen.

right: UInt16

Divisorn.

Returer

ValueTuple<UInt16,UInt16>

Kvoten och resten av de angivna talen.

Attribut: CLSCompliantAttribute

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(SByte, SByte)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Viktigt!

Detta API uppfyller inte CLS.

Genererar kvoten och resten av två signerade 8-bitarsnummer.

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)

Parametrar

left: SByte

Utdelningen.

right: SByte

Divisorn.

Returer

ValueTuple<SByte,SByte>

Kvoten och resten av de angivna talen.

Attribut: CLSCompliantAttribute

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(Int64, Int64)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Genererar kvoten och resten av två signerade 64-bitarsnummer.

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)

Parametrar

left: Int64

Utdelningen.

right: Int64

Divisorn.

Returer

ValueTuple<Int64,Int64>

Kvoten och resten av de angivna talen.

Undantag

DivideByZeroException

right är noll.

OverflowException

left är Int64.MinValue och right är -1.

Gäller för

DivRem(Int32, Int32)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Genererar kvoten och resten av två signerade 32-bitarsnummer.

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)

Parametrar

left: Int32

Utdelningen.

right: Int32

Divisorn.

Returer

ValueTuple<Int32,Int32>

Kvoten och resten av de angivna talen.

Undantag

DivideByZeroException

right är noll.

OverflowException

left är Int32.MinValue och right är -1.

Gäller för

DivRem(Int16, Int16)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Genererar kvoten och resten av två signerade 16-bitarsnummer.

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)

Parametrar

left: Int16

Utdelningen.

right: Int16

Divisorn.

Returer

ValueTuple<Int16,Int16>

Kvoten och resten av de angivna talen.

Gäller för

DivRem(Byte, Byte)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Genererar kvoten och resten av två osignerade 8-bitars tal.

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)

Parametrar

left: Byte

Utdelningen.

right: Byte

Divisorn.

Returer

ValueTuple<Byte,Byte>

Kvoten och resten av de angivna talen.

Undantag

DivideByZeroException

right är noll.

Gäller för

DivRem(IntPtr, IntPtr)

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Källa:: Math.cs

Genererar kvoten och resten av två signerade interna tal.

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)

Parametrar

left: IntPtr
nint

nativeint

Utdelningen.

right: IntPtr
nint

nativeint

Divisorn.

Returer

ValueTuple<IntPtr,IntPtr>

ValueTuple<nativeint,nativeint>

Kvoten och resten av de angivna talen.

Undantag

DivideByZeroException

right är noll.

OverflowException

left är IntPtr.MinValue och right är -1.

Gäller för

Feedback

Var den här sidan till hjälp?