¿Por qué funciona Decimal.Divide (int, int), pero no (int / int)?

Question

¿Cómo es que al dividir dos números int de 32 bits como (int / int) me devuelve 0, pero si uso Decimal.Divide() obtengo la respuesta correcta? De ninguna manera soy un chico de C #.

Answer 1

int es un tipo entero; dividir dos entradas realiza una división entero , es decir, la parte fraccionaria se trunca ya que no puede almacenarse en el tipo de resultado (¡también Decimal!). Decimal.Divide, por el contrario, tiene una parte fraccionaria. Al invocar <=>, sus argumentos <=> se convierten implícitamente en <=> s.

Puede imponer una división no entera en <=> argumentos al convertir explícitamente al menos uno de los argumentos en un tipo de punto flotante, por ejemplo:

int a = 42;
int b = 23;
double result = (double)a / b;

Answer 2

En el primer caso, está haciendo una división de enteros, por lo que el resultado se trunca (la parte decimal se corta) y se devuelve un entero.

En el segundo caso, las entradas se convierten a decimales primero, y el resultado es un decimal. Por lo tanto, no se truncan y obtienes el resultado correcto.

Answer 3

La siguiente línea:

int a = 1, b = 2;
object result = a / b;

... se realizará utilizando aritmética de enteros . Decimal.Divide por otro lado toma dos parámetros del tipo Decimal, por lo que la división se realizará en valores decimales en lugar de valores enteros. Eso es equivalente a esto:

int a = 1, b = 2;
object result = (Decimal)a / (Decimal)b;

Para examinar esto, puede agregar las siguientes líneas de código después de cada uno de los ejemplos anteriores:

Console.WriteLine(result.ToString());
Console.WriteLine(result.GetType().ToString());

La salida en el primer caso será

0
System.Int32

..y en el segundo caso:

0,5
System.Decimal

Answer 4

Creo que Decimal.Divide(decimal, decimal) convierte implícitamente sus 2 argumentos int a decimales antes de devolver un valor decimal (preciso) donde 4/5 se trata como división entera y devuelve 0

Answer 5

Desea emitir los números:

doble c = (doble) a / (doble) b;

Nota: Si alguno de los argumentos en C # es un doble, se usa una doble división que da como resultado un doble. Entonces, lo siguiente también funcionaría:

doble c = (doble) a / b;

aquí hay un pequeño programa:

static void Main(string[] args)
        {
            int a=0, b = 0, c = 0;
            int n = Convert.ToInt16(Console.ReadLine());
            string[] arr_temp = Console.ReadLine().Split(' ');
            int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
            foreach (int i in arr)
            {
                if (i > 0) a++;
                else if (i < 0) b++;
                else c++;
            }
            Console.WriteLine("{0}", (double)a / n);
            Console.WriteLine("{0}", (double)b / n);
            Console.WriteLine("{0}", (double)c / n);
            Console.ReadKey();
        }

Answer 6

Si buscas 0 < a < 1 respuesta, int / int no será suficiente. int / int hace la división entera. Intente lanzar uno de los int a un doble dentro de la operación.

Answer 7

En mi caso, nada funcionó arriba.

lo que quiero hacer es dividir 278 por 575 y multiplicar por 100 para encontrar el porcentaje.

double p = (double)((PeopleCount * 1.0 / AllPeopleCount * 1.0) * 100.0);

%: 48,3478260869565 - > 278/575 --- & Gt; 0 0 %: 51,6521739130435 - & Gt; 297/575 --- & Gt; 0

si multiplico el PeopleCount por 1.0 lo hace decimal y la división será 48.34 ... también multiplique por 100.0 no 100.

Answer 8

La respuesta marcada como tal está muy cerca, pero creo que vale la pena agregar que hay una diferencia entre usar doble y decimal.

No haría un mejor trabajo explicando los conceptos que Wikipedia, así que solo proporcionaré los punteros:

aritmética de punto flotante

tipo de datos decimales

En los sistemas financieros, a menudo es un requisito que podamos garantizar un cierto número de decimales (base-10) de precisión. Esto es generalmente imposible si los datos de entrada / fuente están en base-10 pero realizamos la aritmética en base-2 (porque el número de lugares decimales requeridos para la expansión decimal de un número depende de la base; un tercio toma infinitos decimales lugares para expresar en base-10 como 0.333333 ..., pero solo se necesita un decimal en base-3: 0.1).

Los números de coma flotante son más rápidos para trabajar (en términos de tiempo de CPU; en cuanto a la programación son igualmente simples) y se prefieren cuando se desea minimizar el error de redondeo (como en aplicaciones científicas).