c# - suma - Operaciones decimales y matemáticas.

suma de dos numeros decimales en java

Question

Tengo una simple conversión de un decimal en C #. Se parece a esto:

private decimal BaseValue
{
    get; set;
}

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365 / 360);
    }
}

Sin embargo, esto no funciona. Supongo que porque C # está procesando los números en la fracción como enteros. Así que puedo hacer esto en su lugar (que funciona):

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (decimal)((double)365 / (double)360);
    }
}

Ahora esto parece un poco excesivo, pero puedo vivir con eso. Mi pregunta principal es la siguiente:

¿Por qué Visual Studio me advierte que ''El lanzamiento es redundante'', para el lanzamiento (double) ? Y si elimino la conversión (double) , entonces la (decimal) vuelve redundante. Y si elimino eso, entonces vuelvo a la solución, que no funciona. Ayuda...?

Answer 1

Cualquiera de los dos (dobles) lanzamientos es redundante, pero no ambos. Si cualquier argumento de una operación es doble, el otro argumento se convierte automáticamente en doble. ¿Puedes escribir uno de los argumentos como una constante de número real, por ejemplo, 365.0?

Answer 2

En su ejemplo, puede simplemente dejar los corchetes de distancia:

return BaseValue*365/360;

Answer 3

Hay algunos sufijos para algunos tipos de números, por ejemplo:

 // Use long suffix.
 long l1 = 10000L;

 // Use double suffix.
 double d1 = 123.764D;

 // Use float suffix.
 float f1 = 100.50F;

 // Use unsigned suffix.
 uint u1 = 1000U;

 // Use decimal suffix.
 decimal m2 = 4000.1234M;

 // Use unsigned suffix and long suffix.
 ulong u2 = 10002000300040005000UL;

Los sufijos especifican los tipos de números. Le indican al compilador de C # que un literal integral como 1000 se considere un cierto tipo de número, por ejemplo, un largo (1000L). Nos fijamos en cómo puede agregar sufijos numéricos a los números.

En tu caso:

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365 / 360M);
    }
}

Y también es más claro cuando usas los sufijos en mayúsculas:

Sufijos en minúscula. También puede especificar los sufijos en minúsculas, como u, l, ul, f, d y m. Pero estos son más fáciles de confundir con los números. La letra ''l'' se ve a veces como el número 1.

Answer 4

La decimal es redundante, porque el compilador sabe que desea devolver un decimal .

Uno de los dos conversos double es redundante, porque cuando convierte uno de los int en un double , está claro que usa el operador de double división en lugar de la división entera.

Pero debería ser suficiente con solo usar el sufijo literal decimal m :

return BaseValue * (365m / 360);

Una vez más, una m es suficiente para inferir el operador correcto.

Pero bueno, BaseValue ya es decimal y el paréntesis no tiene sentido (si no quieres una división de enteros) ... esto también debería funcionar:

return BaseValue * 365 / 360;

Answer 5

Simplemente puede usar literales decimales , usando el sufijo m :

public decimal ConvertedValue 
{
    get
    {
        return BaseValue * (365m/360);
    }
}

La razón por la que la segunda conversión es redundante, es porque C # deriva que el primer número (365) en su expresión ((double)365 / (double)360) es un double . Así que para calcular la división, también convertirá implícitamente el segundo artículo a un double . Por lo tanto, no importa si escribe (double) como segundo elemento:

csharp> (double) 365/350        
1.04285714285714                
csharp> (double) 365/ (double) 350
1.04285714285714

Sin embargo, es bastante inútil lanzar a dobles y luego a decimales. Al usar un literal decimal en su expresión, el otro número también será un decimal, y por lo tanto nos quedamos en el mundo decimal .

Answer 6

Solo necesitas uno de los moldes dobles. Asi que

return BaseValue * (decimal)(365/(double)360);

funcionará bien

Una vez que uno es doble, el compilador sabe que debe tratarlo como una división no entera.

Alternativamente

return (BaseValue*365)/360;

trabajará.

o incluso

return BaseValue*365/360;

ya que la multiplicación es de mayor precedencia que la división.

Answer 7

Un doble dividido por un doble es (por supuesto) un doble. Así que lanzar el resultado es redundante.

Sería más corto si simplemente especificas los números como decimales:

 return BaseValue * (365m /360);

Answer 8

simplemente puede agregar el sufijo am a uno de los números para hacerlo decimal:

return BaseValue * (365 / 360m);

Answer 9

una forma de resolver esto es especificando que los números en el cálculo son decimal con una m al final

return BaseValue * (365m / 360m);

¿Por qué Visual Studio me advierte que ''El lanzamiento es redundante'', para el (doble) lanzamiento?

porque cuando tienes un double en un lado de la ecuación, entonces el resultado será un doble.

(double)365 / (double)360

Eche un vistazo a la documentación de las sobrecargas de operadores * . Verás que los operandos son siempre del mismo tipo como:

decimal operator *(decimal x, decimal y);

... entonces la conversión (decimal) se vuelve redundante.

otra vez, porque cuando tienes un decimal en un lado de la ecuación, entonces el resultado será un decimal:

BaseValue * (decimal)(365 / 360)

El problema aquí es el alcance! Todos los resultados de la división se decimal en decimal . En realidad, usted podría resolver su problema simplemente eliminando los paréntesis:

return BaseValue * 365 / 360;

de esta manera, la ecuación será correcta, ya que el resultado de la multiplicación * será un decimal (ya que uno de los operandos es un decimal , el otro se lanzará implícitamente) y nuevamente el resultado de la división también será un decimal para la misma razon.

NOTA: en general, eliminar los paréntesis no es lo mismo que dejarlos. En algunos casos, las operaciones de punto flotante difieren en el resultado cuando cambia el orden de dichas operaciones, aunque las dos expresiones sean matemáticamente idénticas. Comentario de Banex

EDITAR:

El m thingy se llama un literal . Puede encontrar más información sobre todos los sufijos de tipo o literales en la documentación aquí.

Answer 10

use el sufijo m:

return 365m/360 * BaseValue;