Compartir vía


Math.DivRem Método

Definición

Calcula el cociente de dos números y también devuelve el resto en un parámetro de salida.

Sobrecargas

DivRem(Int64, Int64, Int64)

Calcula el cociente de dos enteros con signo de 64 bits y también devuelve el resto en un parámetro de salida.

DivRem(Int32, Int32, Int32)

Calcula el cociente de dos enteros con signo de 32 bits y también devuelve el resto en un parámetro de salida.

DivRem(UIntPtr, UIntPtr)

Genera el cociente y el resto de dos números de tamaño nativo sin signo.

DivRem(UInt64, UInt64)

Genera el cociente y el resto de dos números de 64 bits sin signo.

DivRem(UInt32, UInt32)

Genera el cociente y el resto de dos números de 32 bits sin signo.

DivRem(UInt16, UInt16)

Genera el cociente y el resto de dos números de 16 bits sin signo.

DivRem(SByte, SByte)

Genera el cociente y el resto de dos números de 8 bits con signo.

DivRem(Int64, Int64)

Genera el cociente y el resto de dos números de 64 bits firmados.

DivRem(Int32, Int32)

Genera el cociente y el resto de dos números de 32 bits firmados.

DivRem(Int16, Int16)

Genera el cociente y el resto de dos números de 16 bits firmados.

DivRem(Byte, Byte)

Genera el cociente y el resto de dos números de 8 bits sin signo.

DivRem(IntPtr, IntPtr)

Genera el cociente y el resto de dos números de tamaño nativo firmados.

DivRem(Int64, Int64, Int64)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Calcula el cociente de dos enteros con signo de 64 bits y también devuelve el resto en un parámetro de salida.

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

Parámetros

a
Int64

El dividendo.

b
Int64

Divisor.

result
Int64

Cuando este método vuelve, contiene el resto.

Devoluciones

Cociente de los números especificados.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra el método 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

Comentarios

El valor de resto es igual al resultado del operador de resto .

Consulte también

Se aplica a

DivRem(Int32, Int32, Int32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Calcula el cociente de dos enteros con signo de 32 bits y también devuelve el resto en un parámetro de salida.

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

Parámetros

a
Int32

El dividendo.

b
Int32

Divisor.

result
Int32

Cuando este método vuelve, contiene el resto.

Devoluciones

Cociente de los números especificados.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra el método 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

Comentarios

El valor de resto es igual al resultado del operador de resto .

Consulte también

Se aplica a

DivRem(UIntPtr, UIntPtr)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Importante

Esta API no es conforme a CLS.

Genera el cociente y el resto de dos números de tamaño nativo sin signo.

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)

Parámetros

left
UIntPtr

nuint

unativeint

El dividendo.

right
UIntPtr

nuint

unativeint

Divisor.

Devoluciones

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

Cociente y el resto de los números especificados.

Atributos

Se aplica a

DivRem(UInt64, UInt64)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Importante

Esta API no es conforme a CLS.

Genera el cociente y el resto de dos números de 64 bits sin signo.

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)

Parámetros

left
UInt64

El dividendo.

right
UInt64

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Atributos

Se aplica a

DivRem(UInt32, UInt32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Importante

Esta API no es conforme a CLS.

Genera el cociente y el resto de dos números de 32 bits sin signo.

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)

Parámetros

left
UInt32

El dividendo.

right
UInt32

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Atributos

Se aplica a

DivRem(UInt16, UInt16)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Importante

Esta API no es conforme a CLS.

Genera el cociente y el resto de dos números de 16 bits sin signo.

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)

Parámetros

left
UInt16

El dividendo.

right
UInt16

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Atributos

Se aplica a

DivRem(SByte, SByte)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Importante

Esta API no es conforme a CLS.

Genera el cociente y el resto de dos números de 8 bits con signo.

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)

Parámetros

left
SByte

El dividendo.

right
SByte

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Atributos

Se aplica a

DivRem(Int64, Int64)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Genera el cociente y el resto de dos números de 64 bits firmados.

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)

Parámetros

left
Int64

El dividendo.

right
Int64

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Se aplica a

DivRem(Int32, Int32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Genera el cociente y el resto de dos números de 32 bits firmados.

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)

Parámetros

left
Int32

El dividendo.

right
Int32

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Se aplica a

DivRem(Int16, Int16)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Genera el cociente y el resto de dos números de 16 bits firmados.

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)

Parámetros

left
Int16

El dividendo.

right
Int16

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Se aplica a

DivRem(Byte, Byte)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Genera el cociente y el resto de dos números de 8 bits sin signo.

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)

Parámetros

left
Byte

El dividendo.

right
Byte

Divisor.

Devoluciones

Cociente y el resto de los números especificados.

Se aplica a

DivRem(IntPtr, IntPtr)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Genera el cociente y el resto de dos números de tamaño nativo firmados.

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)

Parámetros

left
IntPtr

nint

nativeint

El dividendo.

right
IntPtr

nint

nativeint

Divisor.

Devoluciones

ValueTuple<IntPtr,IntPtr>

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

Cociente y el resto de los números especificados.

Se aplica a