Unterschied zwischen Math.Floor () und Math.Truncate ()

9 answers
  • Folgen Sie diesen Links für die MSDN-Beschreibungen von:

    • Math.Floor , was auf negative Unendlichkeit hin abrundet.
    • Math.Ceiling , was sich in Richtung positiver Unendlichkeit abrundet.
    • Math.Truncate , was abrundet oder gegen Null.
    • Math.Round , wobei auf die nächste Ganzzahl oder die angegebene Anzahl von Dezimalstellen gerundet wird. Sie können das Verhalten angeben, wenn es genau zwischen zwei Möglichkeiten äquidistant ist, z. B. durch Rundung, so dass die letzte Ziffer gerade ist ("Round(2.5,MidpointRounding.ToEven)" wird 2) oder so, dass sie weiter von Null entfernt ist ("Round(2.5,MidpointRounding.AwayFromZero)" wird 3).

    Das folgende Diagramm und die folgende Tabelle können hilfreich sein:

     -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
     

    Beachten Sie, dass Round viel leistungsfähiger ist, als es scheint, einfach weil es auf eine bestimmte Anzahl von Dezimalstellen gerundet werden kann. Alle anderen runden immer auf null Dezimalstellen. Zum Beispiel:

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

    Bei den anderen Funktionen müssen Sie die Multiplikations- / Divisions-Trickserie verwenden, um denselben Effekt zu erzielen :

     c = System.Math.Truncate (n * 100) / 100;                    // 3.14
    d = System.Math.Ceiling (n * 100) / 100;                     // 3.15
     
    27 December 2012
    luiges90JRafaelM
  • Math.Floor() rundet auf negative Unendlichkeit

    Math.Truncate rundet auf Null zu.

    For Beispiel:

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

    während

     Math.Floor(3.4)     = 3
    Math.Truncate(3.4)  = 3
     
    11 November 2017
    Azhar
  • Einige Beispiele:

     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
     
    25 February 2009
    Marek Grzenkowiczten2net
  • Sie entsprechen funktional positiven Zahlen. Der Unterschied liegt im Umgang mit negativen Zahlen.

    Zum Beispiel:

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

    MSDN-Links: - Math.Floor-Methode - Math.Truncate-Methode

    PS Hüten Sie sich vor Math.Round. Es ist möglicherweise nicht das, was Sie erwarten.

    Um das Rundungsergebnis "Standard" zu erhalten, verwenden Sie:

     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
     
    18 April 2016
    Sнаđошƒаӽ
  • Math.Floor() Runden "in Richtung negativer Unendlichkeit" gemäß Abschnitt 4 von IEEE-Standard 754

    Math.Truncate() rundet "auf die nächste ganze Zahl auf Null".

    07 June 2012
  • math.floor()

    Gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Zahl ist.

    MSDN system.math.floor

    math.truncate()

    Berechnet den integralen Teil einer Zahl.

    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
     

    Zusätzlich 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
     
    04 April 2017
    safin chacko
  • Math.Floor(): Gibt die größte Ganzzahl unter oder gleich der angegebenen Gleitkommazahl mit doppelter Genauigkeit zurück.

    Math.Round(): Rundet einen Wert auf die nächste Ganzzahl oder die angegebene Anzahl von Nachkommastellen.

    18 April 2016
    Sнаđошƒаӽ
  • Math.floor nach links schieben ...
    Math.ceil nach rechts schieben ...
    Math.truncate criiiiss crooooss (Boden / Decke immer in Richtung 0)
    Math.round cha cha, echt glatt ... (zur nächsten Seite gehen)

    Lass uns zur Arbeit gehen! (⌐ □ _ □)

    Nach links ... Math.floor
    Nehmen Sie es jetzt zurück y'a ll... --< / code>
    Zwei Sprünge dieser Zeit me... -=2< / code>

    Jeder klatscht in die Hände ✋✋

    Wie niedrig kann das sein du gehst? Kannst du tief gehen? Alles im ganzen ay to the fl oder ?

      if (das == "falsch") 
     zurückgeben "Ich will nicht recht sein"; 
      

    Math.truncate (x) stimmt mit int (x) überein.
    durch Entfernen eines Positivs oder negativer Bruchteil, Sie gehen immer in Richtung 0.

    22 February 2018
    DezDespertar
  • Mat.floor () wird immer abgerundet, dh es wird eine LESSER-Ganzzahl zurückgegeben. Während round () die NEAREST-Ganzzahl zurückgibt

    17 July 2018
    vidy