Vă mulțumim pentru susținere

Diferența dintre Math.Floor () și Math.Truncate ()

Care este diferența dintre Math.Floor () și Math.Truncate () în .NET?

0
adăugat editat
ai nevoie de acest lucru după 10 ani impar? laugh out loud
adăugat autor L_Church
de ce după 10 ani există o recompensă? există deja multe răspunsuri. este ceva ce lipsesc aici?
adăugat autor Puddle
de exemplu. Math.Floor (5.4) = 5 Math.Truncate (5.4) = 5
adăugat autor subramani

8 răspunsuri

Math.Floor rounds down, Math.Ceiling rounds up, and Math.Truncate rounds towards zero. Thus, Math.Truncate is like Math.Floor for positive numbers, and like Math.Ceiling for negative numbers. Here's the reference.

For completeness, Math.Round rounds to the nearest integer. If the number is exactly midway between two integers, then it rounds towards the even one. Reference.

Vezi și: Răspunsul lui Pax Diablo . Foarte recomandat!

0
adăugat
Ce este (int) egal în clasa Math?
adăugat autor Lei Yang
Când (int) myDouble diferă de (int) Math.Truncate (myDouble) ?
adăugat autor mpen
@Chris, vă sugerez să vă fixați descrierea Rundei, există două modalități de rotunjire (AwayFromZero și ToEven) și nu se rotunjează la cel mai apropiat număr întreg, deoarece poate face și rotunjire fracționată.
adăugat autor paxdiablo
Deci, doar o scurtă adăugare la întrebarea inițială - care este diferența dintre Math.Truncate și turnarea doar un zecimal sau dublu la int? nu ar fi, de asemenea, rotunde spre zero?
adăugat autor Noam Gal

Cateva exemple:

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
0
adăugat

Urmați aceste linkuri pentru descrierile MSDN ale:

  • Math.Floor, which rounds down towards negative infinity.
  • Math.Ceiling, which rounds up towards positive infinity.
  • Math.Truncate, which rounds up or down towards zero.
  • Math.Round, which rounds to the nearest integer or specified number of decimal places. You can specify the behavior if it's exactly equidistant between two possibilities, such as rounding so that the final digit is even ("Round(2.5,MidpointRounding.ToEven)" becoming 2) or so that it's further away from zero ("Round(2.5,MidpointRounding.AwayFromZero)" becoming 3).

Diagrama și tabelul de mai jos vă pot ajuta:

-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

Rețineți că Round este mult mai puternic decât pare, pur și simplu pentru că poate rotunji la un anumit număr de zecimale. Toți ceilalți rotunjește la zero zecimale întotdeauna. De exemplu:

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

Cu celelalte funcții, trebuie să folosiți trickery multiplica / împărți pentru a obține același efect:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15
0
adăugat
Multumesc, @dtroy, n-am avut niciodata nevoie sa folosesc acel mod si, in timp ce l-am documentat corect in cazul in care textul, am luat in totalitate exemple greșit. Sperăm că este rezolvată acum.
adăugat autor paxdiablo
@Richiban, gândiți-vă la even ca proprietate a cifrei finale în numărul rotunjit, nu ca în sensul întregului număr Două. Apropo, îmi pare rău că a durat atât de mult pentru a te întoarce la tine, sper că nu stai doar să aștepți răspunsul meu :-)
adăugat autor paxdiablo
Pax, cred că ai o greșeală cu: Round (AwayFromZero) -3 -2 1 2 3 Math.Round (-1.2, MidpointRounding.AwayFromZero) == -1 Math.Round (0.3, MidpointRounding.AwayFromZero) == 0.0 etc ..
adăugat autor dtroy
Ne pare rău că am comentat o astfel de întrebare veche, dar trebuie să întreb: Cum puteți rotunji "ToEven" cu două zecimale? Cu siguranță ciudat și chiar se aplică doar la întregi?
adăugat autor Richiban

Math.Floor() rounds toward negative infinity

Math.Truncate rounds up or down towards zero.

De exemplu:

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

in timp ce

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3
0
adăugat

Math.floor sliiiide to the left...
Math.ceil sliiiide to the right...
Math.truncate criiiiss crooooss (floor/ceil always towards 0)
Math.round cha cha, real smooth... (go to closest side)

Să mergem la treabă! (?? _?)

To the left... Math.floor
Take it back now y'all... --
Two hops this time... -=2

Toată lumea vă bate mâinile?

Cat de josnic poti sa fii? Poți să te duci jos? Până la floor ?

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

Math.truncate(x) is also the same as int(x).
by removing a positive or negative fraction, you're always heading towards 0.

0
adăugat

Math.floor ()

Returnează cel mai mare număr întreg mai mic sau egal cu numărul specificat.

MSDN system.math.floor

math.truncate ()

Calculează partea integrală a unui număr.

MSDN system.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

In addition 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
0
adăugat

Math.Floor(): Returns the largest integer less than or equal to the specified double-precision floating-point number.

Math.Round(): Rounds a value to the nearest integer or to the specified number of fractional digits.

0
adăugat
OP a întrebat despre diferența dintre Floor () și Truncate () , nu Floor () și Round <) >.
adăugat autor Robert Columbia

Ele sunt echivalente funcțional cu numere pozitive. Diferența este în modul în care gestionează numerele negative.

De exemplu:

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

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

MSDN links: - Math.Floor Method - Math.Truncate Method

P.S. Feriți-vă de Math.Round este posibil să nu fie ceea ce vă așteptați.

Pentru a obține rezultatul "standard" de rotunjire, utilizați:

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
0
adăugat