Math.DivRem Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Calcule le quotient de deux nombres et retourne également le reste dans un paramètre de sortie.

Surcharges

DivRem(Int64, Int64, Int64)	Calcule le quotient de deux entiers signés 64 bits et retourne également le reste dans un paramètre de sortie.
DivRem(Int32, Int32, Int32)	Calcule le quotient de deux entiers signés 32 bits et retourne également le reste dans un paramètre de sortie.
DivRem(UIntPtr, UIntPtr)	Produit le quotient et le reste de deux nombres de taille native non signés.
DivRem(UInt64, UInt64)	Produit le quotient et le reste de deux nombres 64 bits non signés.
DivRem(UInt32, UInt32)	Produit le quotient et le reste de deux nombres 32 bits non signés.
DivRem(UInt16, UInt16)	Produit le quotient et le reste de deux nombres 16 bits non signés.
DivRem(SByte, SByte)	Produit le quotient et le reste de deux nombres 8 bits signés.
DivRem(Int64, Int64)	Produit le quotient et le reste de deux nombres 64 bits signés.
DivRem(Int32, Int32)	Produit le quotient et le reste de deux nombres 32 bits signés.
DivRem(Int16, Int16)	Produit le quotient et le reste de deux nombres 16 bits signés.
DivRem(Byte, Byte)	Produit le quotient et le reste de deux nombres 8 bits non signés.
DivRem(IntPtr, IntPtr)	Produit le quotient et le reste de deux nombres de taille native signés.

DivRem(Int64, Int64, Int64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Calcule le quotient de deux entiers signés 64 bits et retourne également le reste dans un paramètre de sortie.

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

Paramètres

a: Int64

Le dividende.

b: Int64

Diviseur.

result: Int64

Lorsque cette méthode est retournée, contient le reste.

Retours

Int64

Quotient des nombres spécifiés.

Exceptions

DivideByZeroException

b est égal à zéro.

Exemples

L’exemple suivant illustre la méthode 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

Remarques

La valeur restante est égale au résultat de l’opérateur de reste .

Voir aussi

IEEERemainder(Double, Double)

S’applique à

DivRem(Int32, Int32, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Calcule le quotient de deux entiers signés 32 bits et retourne également le reste dans un paramètre de sortie.

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

Paramètres

a: Int32

Le dividende.

b: Int32

Diviseur.

result: Int32

Lorsque cette méthode est retournée, contient le reste.

Retours

Int32

Quotient des nombres spécifiés.

Exceptions

DivideByZeroException

b est égal à zéro.

Exemples

L’exemple suivant illustre la méthode 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

Remarques

La valeur restante est égale au résultat de l’opérateur de reste .

Voir aussi

IEEERemainder(Double, Double)

S’applique à

DivRem(UIntPtr, UIntPtr)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Cette API n’est pas conforme CLS.

Produit le quotient et le reste de deux nombres de taille native non signés.

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)

Paramètres

left: UIntPtr
nuint

unativeint

Le dividende.

right: UIntPtr
nuint

unativeint

Diviseur.

Retours

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

Quotient et le reste des nombres spécifiés.

Attributs: CLSCompliantAttribute

S’applique à

DivRem(UInt64, UInt64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Cette API n’est pas conforme CLS.

Produit le quotient et le reste de deux nombres 64 bits non signés.

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)

Paramètres

left: UInt64

Le dividende.

right: UInt64

Diviseur.

Retours

ValueTuple<UInt64,UInt64>

Quotient et le reste des nombres spécifiés.

Attributs: CLSCompliantAttribute

S’applique à

DivRem(UInt32, UInt32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Cette API n’est pas conforme CLS.

Produit le quotient et le reste de deux nombres 32 bits non signés.

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)

Paramètres

left: UInt32

Le dividende.

right: UInt32

Diviseur.

Retours

ValueTuple<UInt32,UInt32>

Quotient et le reste des nombres spécifiés.

Attributs: CLSCompliantAttribute

S’applique à

DivRem(UInt16, UInt16)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Cette API n’est pas conforme CLS.

Produit le quotient et le reste de deux nombres 16 bits non signés.

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)

Paramètres

left: UInt16

Le dividende.

right: UInt16

Diviseur.

Retours

ValueTuple<UInt16,UInt16>

Quotient et le reste des nombres spécifiés.

Attributs: CLSCompliantAttribute

S’applique à

DivRem(SByte, SByte)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Important

Cette API n’est pas conforme CLS.

Produit le quotient et le reste de deux nombres 8 bits signés.

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)

Paramètres

left: SByte

Le dividende.

right: SByte

Diviseur.

Retours

ValueTuple<SByte,SByte>

Quotient et le reste des nombres spécifiés.

Attributs: CLSCompliantAttribute

S’applique à

DivRem(Int64, Int64)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Produit le quotient et le reste de deux nombres 64 bits signés.

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)

Paramètres

left: Int64

Le dividende.

right: Int64

Diviseur.

Retours

ValueTuple<Int64,Int64>

Quotient et le reste des nombres spécifiés.

S’applique à

DivRem(Int32, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Produit le quotient et le reste de deux nombres 32 bits signés.

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)

Paramètres

left: Int32

Le dividende.

right: Int32

Diviseur.

Retours

ValueTuple<Int32,Int32>

Quotient et le reste des nombres spécifiés.

S’applique à

DivRem(Int16, Int16)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Produit le quotient et le reste de deux nombres 16 bits signés.

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)

Paramètres

left: Int16

Le dividende.

right: Int16

Diviseur.

Retours

ValueTuple<Int16,Int16>

Quotient et le reste des nombres spécifiés.

S’applique à

DivRem(Byte, Byte)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Produit le quotient et le reste de deux nombres 8 bits non signés.

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)

Paramètres

left: Byte

Le dividende.

right: Byte

Diviseur.

Retours

ValueTuple<Byte,Byte>

Quotient et le reste des nombres spécifiés.

S’applique à

DivRem(IntPtr, IntPtr)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Produit le quotient et le reste de deux nombres de taille native signés.

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)

Paramètres

left: IntPtr
nint

nativeint

Le dividende.

right: IntPtr
nint

nativeint

Diviseur.

Retours

ValueTuple<IntPtr,IntPtr>

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

Quotient et le reste des nombres spécifiés.

S’applique à

Partager via

Math.DivRem Méthode

Définition

Surcharges

DivRem(Int64, Int64, Int64)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

DivRem(Int32, Int32, Int32)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

DivRem(UIntPtr, UIntPtr)

Paramètres

Retours

S’applique à

DivRem(UInt64, UInt64)

Paramètres

Retours

S’applique à

DivRem(UInt32, UInt32)

Paramètres

Retours

S’applique à

DivRem(UInt16, UInt16)

Paramètres

Retours

S’applique à

DivRem(SByte, SByte)

Paramètres

Retours

S’applique à

DivRem(Int64, Int64)

Paramètres

Retours

S’applique à

DivRem(Int32, Int32)

Paramètres

Retours

S’applique à

DivRem(Int16, Int16)

Paramètres

Retours

S’applique à

DivRem(Byte, Byte)

Paramètres

Retours

S’applique à

DivRem(IntPtr, IntPtr)

Paramètres

Retours

S’applique à

Ressources supplémentaires