Diferencia entre Math.Floor () y Math.Truncate ()

¿Cuál es la diferencia entre Math.Floor()y Math.Truncate()en .NET?

Math.Floorredondea hacia abajo, Math.Ceilingredondea hacia arriba y Math.Truncateredondea hacia cero. Por lo tanto, Math.Truncatees como Math.Floorpara números positivos y como Math.Ceilingpara números negativos. Aquí está la referencia .

Para completar, se Math.Roundredondea al entero más cercano. Si el número está exactamente a medio camino entre dos enteros, entonces se redondea hacia el par. Referencia.

Ver también: la respuesta de Pax Diablo . ¡Muy recomendable!

Siga estos enlaces para las descripciones de MSDN de:

• Math.Floor, que se redondea hacia el infinito negativo.
• Math.Ceiling, que se redondea hacia el infinito positivo.
• Math.Truncate, que se redondea hacia arriba o hacia abajo hacia cero.
• Math.Round, que se redondea al número entero más cercano o al número especificado de lugares decimales. Puede especificar el comportamiento si es exactamente equidistante entre dos posibilidades, como redondear para que el dígito final sea par (" Round(2.5,MidpointRounding.ToEven)" se convierte en 2) o para que esté más alejado de cero (" Round(2.5,MidpointRounding.AwayFromZero)" se convierta en 3).

El siguiente diagrama y tabla pueden ayudar:

-3        -2        -1         0         1         2         3
 +--|------+---------+----|----+--|------+----|----+-------|-+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round (ToEven)           -3       0      0      2      3
Round (AwayFromZero)     -3      -1      0      2      3

Tenga en cuenta que Roundes mucho más poderoso de lo que parece, simplemente porque puede redondear a un número específico de decimales. Todos los demás redondean a cero decimales siempre. Por ejemplo:

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

Con las otras funciones, debe usar el truco de multiplicar / dividir para lograr el mismo efecto:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15

Math.Floor() redondea hacia el infinito negativo

Math.Truncate redondea hacia arriba o hacia abajo hacia cero.

Por ejemplo:

Math.Floor(-3.4)     = -4
Math.Truncate(-3.4)  = -3

mientras

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3

Algunos ejemplos:

Round(1.5) = 2
Round(2.5) = 2
Round(1.5, MidpointRounding.AwayFromZero) = 2
Round(2.5, MidpointRounding.AwayFromZero) = 3
Round(1.55, 1) = 1.6
Round(1.65, 1) = 1.6
Round(1.55, 1, MidpointRounding.AwayFromZero) = 1.6
Round(1.65, 1, MidpointRounding.AwayFromZero) = 1.7

Truncate(2.10) = 2
Truncate(2.00) = 2
Truncate(1.90) = 1
Truncate(1.80) = 1

Math.floorsliiiide a la izquierda ...
Math.ceilsliiiide a la derecha ...
Math.truncatecriiiiss crooooss (suelo / techo siempre hacia 0)
Math.roundcha cha, muy suave ... (ir al lado más cercano)

¡Vamos a trabajar! (⌐ □ _ □)

A la izquierda ... Math.floor
Tómalo de vuelta ahora ... --
Dos saltos esta vez ...-=2

Todos aplauden hands

¿Cuan bajo Puedes ir? ¿Puedes bajar? Todo el camino hasta el floor?

if (this == "wrong")
    return "i don't wanna be right";

Math.truncate(x)también es lo mismo que int(x).
Al eliminar una fracción positiva o negativa, siempre te diriges hacia 0.

Son funcionalmente equivalentes con números positivos. La diferencia está en cómo manejan los números negativos.

Por ejemplo:

Math.Floor(2.5) = 2
Math.Truncate(2.5) = 2

Math.Floor(-2.5) = -3
Math.Truncate(-2.5) = -2

Enlaces de MSDN: - Método Math.Floor - Método Math.Truncate

PD: Cuidado con las matemáticas, puede que no sea lo que esperas.

Para obtener el resultado de redondeo "estándar", use:

float myFloat = 4.5;
Console.WriteLine( Math.Round(myFloat) ); // writes 4
Console.WriteLine( Math.Round(myFloat, 0, MidpointRounding.AwayFromZero) ) //writes 5
Console.WriteLine( myFloat.ToString("F0") ); // writes 5

Pruebe esto, ejemplos:

Math.Floor () vs Math.Truncate ()

Math.Floor(2.56) = 2
Math.Floor(3.22) = 3
Math.Floor(-2.56) = -3
Math.Floor(-3.26) = -4

Math.Truncate(2.56) = 2
Math.Truncate(2.00) = 2
Math.Truncate(1.20) = 1
Math.Truncate(-3.26) = -3
Math.Truncate(-3.96) = -3

También Math.Round ()

   Math.Round(1.6) = 2
   Math.Round(-8.56) = -9
   Math.Round(8.16) = 8
   Math.Round(8.50) = 8
   Math.Round(8.51) = 9

math.floor()

Devuelve el entero más grande menor o igual que el número especificado. MSDN system.math.floor

math.truncate()

Calcula la parte integral de un número. MSDN system.math.truncate

Math.Floor()redondea "hacia el infinito negativo" de conformidad con la norma IEEE 754 sección 4.

Math.Truncate() redondea "al entero más cercano hacia cero".

Math.Floor(): Devuelve el entero más grande menor o igual que el número de punto flotante de precisión doble especificado.

Math.Round(): Redondea un valor al entero más cercano o al número especificado de dígitos fraccionarios.

Math.floor()siempre se redondeará hacia abajo, es decir, devuelve un entero MENOR. Mientras round()que devolverá el entero MÁS CERCANO

math.floor ()

Devuelve el entero más grande menor o igual que el número especificado.

math.truncate ()

Calcula la parte integral de un número.

Truncar cae el decimal ****