Differenza tra Math.Floor () e Math.Truncate ()

Qual è la differenza tra Math.Floor()e Math.Truncate()in .NET?

Math.Floorarrotonda, Math.Ceilingarrotonda e Math.Truncatearrotonda verso lo zero. Quindi, Math.Truncateè come Math.Floorper i numeri positivi e come Math.Ceilingper i numeri negativi. Ecco il riferimento .

Per completezza, Math.Roundarrotonda al numero intero più vicino. Se il numero è esattamente a metà strada tra due numeri interi, si arrotonda verso quello pari. Riferimento.

Vedi anche: la risposta di Pax Diablo . Altamente raccomandato!

Segui questi collegamenti per le descrizioni MSDN di:

• Math.Floor, che si arrotonda verso l'infinito negativo.
• Math.Ceiling, che arrotonda verso l'infinito positivo.
• Math.Truncate, che arrotonda per eccesso o per difetto verso zero.
• Math.Round, che viene arrotondato al numero intero più vicino o al numero specificato di posizioni decimali. È possibile specificare il comportamento se è esattamente equidistante tra due possibilità, come arrotondare in modo che la cifra finale sia pari (" Round(2.5,MidpointRounding.ToEven)" diventando 2) o in modo che sia più lontana da zero (" Round(2.5,MidpointRounding.AwayFromZero)" diventando 3).

Il diagramma e la tabella seguenti possono essere d'aiuto:

-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

Nota che Roundè molto più potente di quanto sembri, semplicemente perché può arrotondare a un numero specifico di cifre decimali. Tutti gli altri arrotondano sempre a zero decimali sempre. Per esempio:

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

Con le altre funzioni, devi usare l'inganno moltiplicare / dividere per ottenere lo stesso effetto:

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

Math.Floor() arrotonda verso l'infinito negativo

Math.Truncate arrotonda per eccesso o per difetto verso zero.

Per esempio:

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

mentre

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

Qualche esempio:

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 sinistra ...
Math.ceilsliiiide a destra ...
Math.truncatecriiiiss crooooss (pavimento / soffitto sempre verso 0)
Math.roundcha cha, real smooth ... (vai al lato più vicino)

Andiamo a lavorare! (⌐ □ □ _)

A sinistra ... Math.floor
Riprendilo ora tutti ... --
Due salti questa volta ...-=2

Tutti battono le mani ✋✋

Quanto in basso si può andare? Puoi scendere in basso? Fino al floor?

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

Math.truncate(x)è anche lo stesso di int(x).
rimuovendo una frazione positiva o negativa, vai sempre verso 0.

Sono funzionalmente equivalenti con numeri positivi. La differenza sta nel modo in cui gestiscono i numeri negativi.

Per esempio:

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

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

Collegamenti MSDN: - Metodo Math.Floor - Metodo Math.Truncate

PS: fai attenzione alla matematica, perché potrebbe non essere quello che ti aspetti.

Per ottenere il risultato di arrotondamento "standard" utilizzare:

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

Prova questo, esempi:

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

Anche 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()

Restituisce il numero intero più grande minore o uguale al numero specificato. MSDN system.math.floor

math.truncate()

Calcola la parte integrale di un numero. MSDN system.math.truncate

Math.Floor()arrotonda "verso l'infinito negativo" in conformità allo standard IEEE 754 sezione 4.

Math.Truncate() arrotonda "al numero intero più vicino verso zero".

Math.Floor(): Restituisce il numero intero più grande minore o uguale al numero in virgola mobile a precisione doppia specificato.

Math.Round(): Arrotonda un valore all'intero più vicino o al numero specificato di cifre frazionarie.

Math.floor()verrà sempre arrotondato per es., restituisce LESSER intero. Mentre round()restituirà il numero intero PIÙ VICINO

Math.floor ()

Restituisce il numero intero più grande minore o uguale al numero specificato.

math.truncate ()

Calcola la parte integrale di un numero.

Troncare rilascia il decimale ****