Diferença entre Math.Floor () e Math.Truncate ()

Qual é a diferença entre Math.Floor()e Math.Truncate()no .NET?

Math.Floorarredonda para baixo, Math.Ceilingarredonda para cima e Math.Truncatearredonda para zero. Assim, Math.Truncateé como Math.Floorpara números positivos e como Math.Ceilingpara números negativos. Aqui está a referência .

Para completar, Math.Roundarredonda para o número inteiro mais próximo. Se o número estiver exatamente no meio do caminho entre dois números inteiros, ele arredonda para o número par. Referência.

Veja também: Resposta de Pax Diablo . Altamente recomendado!

Siga estes links para as descrições do MSDN de:

• Math.Floor, que arredonda para o infinito negativo.
• Math.Ceiling, que arredonda para o infinito positivo.
• Math.Truncate, que arredonda para cima ou para baixo em direção a zero.
• Math.Round, que arredonda para o número inteiro mais próximo ou o número especificado de casas decimais. Você pode especificar o comportamento se ele for exatamente equidistante entre duas possibilidades, como o arredondamento para que o dígito final seja par (" Round(2.5,MidpointRounding.ToEven)" se torne 2) ou para que fique mais longe de zero (" Round(2.5,MidpointRounding.AwayFromZero)" se torne 3).

O diagrama e tabela a seguir podem ajudar:

-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

Observe que Roundé muito mais poderoso do que parece, simplesmente porque pode arredondar para um número específico de casas decimais. Todos os outros arredondam para zero decimais sempre. Por exemplo:

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

Com as outras funções, você deve usar truques de multiplicar / dividir para obter o mesmo efeito:

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

Math.Floor() arredonda para o infinito negativo

Math.Truncate arredonda para cima ou para baixo em direção a zero.

Por exemplo:

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

enquanto

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

Alguns exemplos:

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 para a esquerda ...
Math.ceilsliiiide para a direita ...
Math.truncatecriiiiss crooooss (piso / teto sempre em direção a 0)
Math.roundcha cha, bem suave ... (vá para o lado mais próximo)

Vamos trabalhar! (⌐ □ _ □)

Para a esquerda ... Math.floor
Volte agora ... --
Dois saltos desta vez ...-=2

Todo mundo bate palmas ✋✋

Quão baixo você pode ir? Você pode descer baixo? Todo o caminho para o floor?

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

Math.truncate(x)também é o mesmo que int(x).
removendo uma fração positiva ou negativa, você está sempre indo para o zero.

Eles são funcionalmente equivalentes a números positivos. A diferença está em como eles lidam com números negativos.

Por exemplo:

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

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

Links do MSDN: - Método Math.Floor - Método Math.Truncate

PS Cuidado com Math.Round pode não ser o que você espera.

Para obter o resultado do arredondamento "padrão", 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

Tente isso, Exemplos:

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

Também 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()

Retorna o maior número inteiro menor ou igual ao número especificado. MSDN system.math.floor

math.truncate()

Calcula a parte integrante de um número. MSDN system.math.truncate

Math.Floor()arredonda "em direção ao infinito negativo", em conformidade com a seção 4 da norma IEEE 754 .

Math.Truncate() arredonda "para o número inteiro mais próximo em direção a zero".

Math.Floor(): Retorna o maior número inteiro menor ou igual ao número de ponto flutuante de precisão dupla especificado.

Math.Round(): Arredonda um valor para o número inteiro mais próximo ou para o número especificado de dígitos fracionários.

Math.floor()sempre arredondará para baixo, ou seja, retornará LESSER inteiro. While round()retornará o número inteiro MAIS PRÓXIMO

math.floor ()

Retorna o maior número inteiro menor ou igual ao número especificado.

math.truncate ()

Calcula a parte integrante de um número.

Truncar descarta o decimal ****