Math.Round Math.Round Math.Round Math.Round Method

Definice

Zaokrouhlí hodnotu na nejbližší celé číslo nebo na zadaný počet zlomkových číslic.Rounds a value to the nearest integer or to the specified number of fractional digits.

Přetížení

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na zadaný počet zlomkových číslic a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet zlomkových číslic a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celé číslo a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet zlomkových číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double) Round(Double) Round(Double) Round(Double)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Zaokrouhlí desítkovou hodnotu na zadaný počet zlomkových číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Příklady

Kromě příkladů v části poznámky obsahuje tento článek příklady, které ilustrují následující přetížení Math.Round metody:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

Math. Round (Decimal)Math.Round(Decimal)
Math. Round (Double)Math.Round(Double)
Math. Round (Decimal, Int32)Math.Round(Decimal, Int32)
Math. Round (Decimal; MidpointRounding)Math.Round(Decimal, MidpointRounding)
Math. Round (Double, Int32)Math.Round(Double, Int32)
Math. Round (Double; MidpointRounding)Math.Round(Double, MidpointRounding)
Math. Round (Decimal, Int32, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)
Math. Round (Double, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Poznámka

Ukázky C#, v tomto článku spusťte Try.NET runner a playground vloženého kódu.The C# examples in this article run in the Try.NET inline code runner and playground. Vyberte spustit tlačítko spustit příklad v interaktivním okně.Select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Poznámky

V této části:In this section:

Jakou metodu mám volat?Which method do I call?

Pomocí následující tabulky můžete vybrat vhodnou metodu zaokrouhlení.You can use the following table to select an appropriate rounding method. Kromě Math.Round metod obsahuje Math.Ceiling také a Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

Chcete-liTo VoláníCall
Zaokrouhlí číslo na celé číslo pomocí zaokrouhlování na nejbližší konvenci.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

-nebo--or-

Round(Double)
Zaokrouhlí číslo na celé číslo pomocí zadané konvence zaokrouhlení.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

-nebo--or-

Round(Double, MidpointRounding)
Zaokrouhlí číslo na zadaný počet zlomkových číslic pomocí zaokrouhlování na nejbližší konvenci.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

-nebo--or-

Round(Double, Int32)
Zaokrouhlí číslo na zadaný počet zlomkových číslic pomocí zadané konvence zaokrouhlení.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

-nebo--or-

Round(Double, Int32, MidpointRounding)
Zaokrouhlí Single hodnotu na zadaný počet zlomkových číslic pomocí zadané konvence zaokrouhlení a minimalizuje ztrátu přesnosti.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Převeďte Single Decimal na voláníRound(Decimal, Int32, MidpointRounding)a.Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Zaokrouhlí číslo na zadaný počet zlomkových číslic a současně minimalizuje problémy přesnosti v hodnotách středního bodu zaokrouhlení.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Zavolejte metodu zaokrouhlení, která implementuje porovnání "větší než nebo rovno".Call a rounding method that implements a "greater than or approximately equal to" comparison. Viz zaokrouhlování a přesnost.See Rounding and precision.
Zaokrouhlí zlomkovou hodnotu na celé číslo, které je větší než desetinná hodnota.Round a fractional value to an integer that is greater than the fractional value. Například zaokrouhlete 3,1 na 4.For example, round 3.1 to 4. Ceiling
Zaokrouhlí zlomkovou hodnotu na celé číslo, které je menší než desetinná hodnota.Round a fractional value to an integer that is less than the fractional value. Například zaokrouhlete 3,9 na 3.For example, round 3.9 to 3. Floor

Střední hodnoty a konvence zaokrouhlováníMidpoint values and rounding conventions

Zaokrouhlení zahrnuje převod číselné hodnoty se zadanou přesností na nejbližší hodnotu s menší přesností.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Například můžete použít Round(Double) metodu k zaokrouhlení hodnoty 3,4 na 3,0 Round(Double, Int32) a metodu pro zaokrouhlení hodnoty 3,579 na 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

V hodnotě středního bodu je hodnota za nejmenší důležitou číslicí ve výsledku přesně poloviční způsob mezi dvěma čísly.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Například hodnota 3,47500 je střední hodnota, pokud má být zaokrouhlena na dvě desetinná místa a 7,500 je střední hodnota, pokud má být zaokrouhlena na celé číslo.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. V těchto případech se nejbližší hodnota nedá snadno identifikovat bez konvence zaokrouhlení.In these cases, the nearest value can't be easily identified without a rounding convention.

Round Metoda podporuje dvě konvence zaokrouhlení pro zpracování hodnot středního bodu:The Round method supports two rounding conventions for handling midpoint values:

  • Zaokrouhlení směrem od nulyRounding away from zero

    Střední hodnoty se zaokrouhlují na další číslo od nuly.Midpoint values are rounded to the next number away from zero. Například 3,75 se zaokrouhlí na 3,8, 3,85 se zaokrouhlí na 3,9,-3,75 se zaokrouhlí na-3,8 a-3,85 se zaokrouhlí na-3,9.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. Tato forma zaokrouhlení je reprezentovaná MidpointRounding.AwayFromZero členem výčtu.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    Zaokrouhlení směrem od nuly je nejrozšířenějším známým formulářem zaokrouhlení.Rounding away from zero is the most widely known form of rounding.

  • Zaokrouhlení na nejbližší nebo zaokrouhlení bankRounding to nearest, or banker's rounding

    Střední hodnoty jsou zaokrouhleny na nejbližší sudé číslo.Midpoint values are rounded to the nearest even number. Například 3,75 a 3,85 se zaokrouhlí na 3,8 a současně na 3,75 a-3,85.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Tato forma zaokrouhlení je reprezentovaná MidpointRounding.ToEven členem výčtu.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    Zaokrouhlení na nejbližší je standardní forma zaokrouhlení, která se používá ve finančních a statistických operacích.Rounding to nearest is the standard form of rounding used in financial and statistical operations. V souladu se standardem IEEE 754, oddílem 4.It conforms to IEEE Standard 754, section 4. Při použití ve více operacích zaokrouhlení zkracuje chybu zaokrouhlování, která je způsobena konzistentním zaokrouhlováním středních hodnot v jednom směru.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. V některých případech může být tato chyba zaokrouhlení významná.In some cases, this rounding error can be significant.

    Následující příklad ukazuje posun, který může být výsledkem konzistentního zaokrouhlování hodnot středního bodu v jednom směru.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. V příkladu je vypočítán skutečný střední hodnota pole Decimal hodnot a pak vypočítá průměr v případě, že hodnoty v poli jsou zaokrouhleny pomocí dvou konvencí.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. V tomto příkladu je hodnota true a střední hodnota, která má za následek zaokrouhlení na nejbližší.In this example, the true mean and the mean that results when rounding to nearest are the same. Ale střední hodnota, která je výsledkem zaokrouhlení směrem od nuly, se liší o .05 (nebo o 3,6%). od skutečné střední hodnoty.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
    decimal sum = 0;
    
    // Calculate true mean.
    foreach (var value in values)
       sum += value;
    
    Console.WriteLine("True mean:     {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding away from zero.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
    
    Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding to nearest.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.ToEven);
    
    Console.WriteLine("ToEven:        {0:N2}", sum/values.Length);
    // The example displays the following output:
    //       True mean:     1.40
    //       AwayFromZero:  1.45
    //       ToEven:        1.40
    
    Module Example
       Public Sub Main()
          Dim values() As Decimal = { 1.15d, 1.25d, 1.35d, 1.45d, 1.55d, 1.65d }
          Dim sum As Decimal
          
          ' Calculate true mean.
          For Each value In values
             sum += value
          Next
          Console.WriteLine("True mean:     {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding away from zero.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
          Next
          Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding to nearest.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.ToEven)
          Next
          Console.WriteLine("ToEven:        {0:N2}", sum/values.Length)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

Ve výchozím nastavení Round používá metoda zaokrouhlování na nejbližší konvenci.By default, the Round method uses the rounding to nearest convention. V následující tabulce jsou uvedena přetížení Round metody a konvence zaokrouhlení, které každý používá.The following table lists the overloads of the Round method and the rounding convention that each uses.

MetodyOverload Konvence zaokrouhleníRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) mode Určeno parametrem.Determined by mode parameter.
Round(Double, MidpointRounding) mode Určeno parametremDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) mode Určeno parametremDetermined by mode parameter
Round(Double, Int32, MidpointRounding) mode Určeno parametremDetermined by mode parameter

Zaokrouhlování a přesnostRounding and precision

Aby bylo možné určit, zda operace zaokrouhlení zahrnuje střední hodnotu, Round metoda vynásobí původní hodnotu, která má být zaokrouhlena o 10n, kde n je požadovaný počet zlomkových číslic v návratové hodnotě a potom Určuje, zda je zbývající část hodnoty větší než nebo rovna. 5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Jedná se o mírnou variaci při testu rovnosti a jak je popsáno v části Double testování rovnosti v referenčním tématu, testy pro rovnost s hodnotami s plovoucí desetinnou čárkou jsou problematické kvůli problémům s formátováním s plovoucí desetinnou čárkou v binárním souboru. reprezentace a přesnostThis is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. To znamená, že desetinná část čísla, která je mírně menší než 0,5 (kvůli ztrátě přesnosti), se nezaokrouhlí směrem nahoru.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Následující příklad ukazuje tento problém.The following example illustrates the problem. Opakovaně přidá číslo 1 až 11,0 a výsledek zaokrouhlí na nejbližší celé číslo.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Bez ohledu na konvenci zaokrouhlení by 11,5 mělo zaokrouhlit na 12.Regardless of the rounding convention, 11.5 should round to 12. Jak však výstup z příkladu ukazuje, není.However, as the output from the example shows, it does not. V příkladu se používá standardní řetězec číselného formátu "R" pro zobrazení plné přesnosti hodnoty s plovoucí desetinnou čárkou a ukazuje, že hodnota, která má být zaokrouhlena, má za opakované přidávání přesnost ztráty a její hodnota je skutečně 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Vzhledem k tomu, že. 499999999999998 je menší než 0,5, hodnota se nezaokrouhlí na nejbližší nejvyšší celé číslo.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Jak je znázorněno v příkladu, k tomuto problému nedojde, pokud jednoduše přiřadíte konstantní hodnotu 11,5 Double proměnné.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero");
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)    
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }
   
   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//       
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//       
//        11.5                 11.5            12              12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1

      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero")
      Console.WriteLine()
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Problémy s přesností v rámci zaokrouhlování hodnot středního bodu jsou pravděpodobně v následujících podmínkách:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

V případech, kdy nedostatek přesnosti v operacích zaokrouhlení je problematický, můžete provést následující akce:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Pokud operace zaokrouhlení volá přetížení, které zaokrouhluje Double hodnotu, můžete Double změnit na Decimal Decimal hodnotu a volat přetížení, které místo toho zaokrouhlí hodnotu.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. I když má datový typ také problémy reprezentace a ztráty přesnosti, jsou tyto problémy mnohem méně běžné. DecimalAlthough the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Definujte vlastní algoritmus zaokrouhlení, který provede "téměř se stejnou" zkoušku k určení, zda je hodnota, která má být zaokrouhlena, přijměte na střední hodnotu.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. Následující příklad definuje RoundApproximate metodu, která prověřuje, zda je desetinná hodnota dostatečně blízko k střední hodnotě, která bude podléhat zaokrouhlení středníku.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Jak výstup z příkladu ukazuje, opravuje problém zaokrouhlení, jak je znázorněno v předchozím příkladu.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero");
          double value = 11.1;
          for (int ctr = 0; ctr <= 5; ctr++)    
             value = RoundValueAndAdd(value);
    
          Console.WriteLine();
    
          value = 11.5;
          RoundValueAndAdd(value);
       }
       
       private static double RoundValueAndAdd(double value)
       {
          const double tolerance = 8e-14;
    
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
          return value + .1;
       }
    
       private static double RoundApproximate(double dbl, int digits, double margin, 
                                         MidpointRounding mode)
       {                                      
          double fraction = dbl * Math.Pow(10, digits);
          double value = Math.Truncate(fraction); 
          fraction = fraction - value;   
          if (fraction == 0)
             return dbl;
          
          double tolerance = margin * dbl;
          // Determine whether this is a midpoint value.
          if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance)) {
             if (mode == MidpointRounding.AwayFromZero)
                return (value + 1)/Math.Pow(10, digits);
             else
                if (value % 2 != 0)
                   return (value + 1)/Math.Pow(10, digits);
                else
                   return value/Math.Pow(10, digits);
          }
          // Any remaining fractional value greater than .5 is not a midpoint value.
          if (fraction > .5)
             return (value + 1)/Math.Pow(10, digits);
          else
             return value/Math.Pow(10, digits);
       }
    }
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //       
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //       
    //        11.5                 11.5            12              12
    
    Module Example
       Public Sub Main()
          Dim value As Double = 11.1
    
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero")
          For ctr As Integer = 0 To 5    
             value = RoundValueAndAdd(value)
          Next
          Console.WriteLine()
    
          value = 11.5
          RoundValueAndAdd(value)
       End Sub
       
       Private Function RoundValueAndAdd(value As Double) As Double
          Const tolerance As Double = 8e-14
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
          Return value + .1
       End Function   
    
       Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double, 
                                         mode As MidpointRounding) As Double
          Dim fraction As Double = dbl * Math.Pow(10, digits)
          Dim value As Double = Math.Truncate(fraction) 
          fraction = fraction - value   
          If fraction = 0 Then Return dbl
          
          Dim tolerance As Double = margin * dbl
          ' Determine whether this is a midpoint value.
          If (fraction >= .5 - tolerance) And (fraction <= .5 + tolerance) Then
             If mode = MidpointRounding.AwayFromZero Then
                Return (value + 1)/Math.Pow(10, digits)
             Else
                If value Mod 2 <> 0 Then
                   Return (value + 1)/Math.Pow(10, digits)
                Else
                   Return value/Math.Pow(10, digits)
                End If
             End If
          End If
          ' Any remaining fractional value greater than .5 is not a midpoint value.
          If fraction > .5 Then
             Return (value + 1)/Math.Pow(10, digits)
          Else
             return value/Math.Pow(10, digits)
          End If      
       End Function
    End Module
    ' The example displays the following output:
    '       Value       Full Precision        ToEven    AwayFromZero
    '       
    '        11.1                 11.1            11              11
    '        11.2                 11.2            11              11
    '        11.3   11.299999999999999            11              11
    '        11.4   11.399999999999999            11              11
    '        11.5   11.499999999999998            12              12
    '        11.6   11.599999999999998            12              12
    '       
    '        11.5                 11.5            12              12
    

Zaokrouhlování a hodnoty s pohyblivou desetinnou čárkou s přesností na jedno desetinné čísloRounding and single-precision floating-point values

Metoda zahrnuje přetížení, která přijímají argumenty typu Decimal a Double. RoundThe Round method includes overloads that accept arguments of type Decimal and Double. Neexistují žádné metody, které by zaokrouhlují Singlehodnoty typu.There are no methods that round values of type Single. Pokud předáte Single hodnotu jednomu z Doublepřetížení Round metody, je přetypování (in C#) nebo převedeno (v Visual Basic) na a a odpovídající Round přetížení s Double parametrem je volána.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. I když je toto rozšiřující převod, často zahrnuje ztrátu přesnosti, jak ukazuje následující příklad.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Pokud je do Round metody předána hodnota16,325azaokrouhlenanadvědesetinnámístapomocízaokrouhlovánínanejbližšíkonvenci,výsledekje16,33anikoliočekávanývýsledek16,32.SingleWhen a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 16.325f;
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, (double) value, 
                        ((double) (value)).GetType().Name);
      Console.WriteLine(Math.Round(value, 2));
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
      Console.WriteLine();
      
      Decimal decValue = (decimal) value;
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name);
      Console.WriteLine(Math.Round(decValue, 2));
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//    
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
Module Example
   Public Sub Main()
      Dim value As Single = 16.325
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, CDbl(value), 
                        CDbl(value).GetType().Name)
      Console.WriteLine(Math.Round(value, 2))
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
      
      Dim decValue As Decimal = CDec(value)
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name)
      Console.WriteLine(Math.Round(decValue, 2))
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Tento neočekávaný výsledek je způsoben ztrátou přesnosti v převodu Single hodnoty Doublena.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Vzhledem k tomu Double , že výsledná hodnota 16.325000762939453 není střední hodnota a je větší než 16,325, je vždy zaokrouhlena nahoru.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

V mnoha případech, jak ukazuje příklad, může být ztráta přesnosti minimalizována nebo odstraněna přetypováním nebo převodem Single hodnoty Decimalna.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Všimněte si, že vzhledem k tomu, že se jedná o zužující převod, vyžaduje použití operátoru přetypování nebo volání metody převodu.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na zadaný počet zlomkových číslic a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parametry

d
Decimal Decimal Decimal Decimal

Zaokrouhlované desetinné číslo.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Počet desetinných míst v návratové hodnotě.The number of decimal places in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Specifikace, která se má d zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.Specification for how to round d if it is midway between two other numbers.

Návraty

Číslo nejbližší k d , které obsahuje počet zlomkových číslic, které decimalsse rovnají.The number nearest to d that contains a number of fractional digits equal to decimals. Pokud d má méně zlomkových číslic, decimalsnež d , se vrátí beze změny.If d has fewer fractional digits than decimals, d is returned unchanged.

Výjimky

decimalsje menší než 0 nebo větší než 28.decimals is less than 0 or greater than 28.

Výsledek je mimo rozsah Decimal.The result is outside the range of a Decimal.

Poznámky

Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Hodnota decimals argumentu může být v rozsahu od 0 do 28.The value of the decimals argument can range from 0 to 28.

PříkladExample

Následující příklad ukazuje, jak použít Round metodu MidpointRounding s výčtem.The following example demonstrates how to use the Round method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
result = Math.Round(negValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(negValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
Console.WriteLine();
/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub 'Main
End Class 'Sample
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'
Viz také

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet zlomkových číslic a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, int digits, MidpointRounding mode);
public static double Round (double value, int digits, MidpointRounding mode);
static member Round : double * int * MidpointRounding -> double
Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parametry

value
Double Double Double Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Počet desetinných číslic ve vrácené hodnotě.The number of fractional digits in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Specifikace, která se má value zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.Specification for how to round value if it is midway between two other numbers.

Návraty

Číslo nejbližší k value číslu, které se digitsrovná počtu zlomkových číslic.The number nearest to value that has a number of fractional digits equal to digits. Pokud value má méně zlomkových číslic, digitsnež value , se vrátí beze změny.If value has fewer fractional digits than digits, value is returned unchanged.

Výjimky

digitsje menší než 0 nebo větší než 15.digits is less than 0 or greater than 15.

Poznámky

Hodnota digits argumentu může být v rozsahu od 0 do 15.The value of the digits argument can range from 0 to 15. Všimněte si, že 15 je maximální počet integrálních a zlomkových číslic, které Double typ podporuje.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Pokud hodnota value argumentu je Double.NaN, vrátí Double.NaNmetoda.If the value of the value argument is Double.NaN, the method returns Double.NaN. Pokud value je Double.PositiveInfinity nebo ,Double.NegativeInfinitymetoda vrátíDouble.PositiveInfinity neboDouble.NegativeInfinityv uvedeném pořadí.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PříkladExample

Následující příklad ukazuje, jak použít Round(Double, Int32, MidpointRounding) metodu MidpointRounding s výčtem.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default. 
 double result = Math.Round(posValue, 1);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
 result = Math.Round(negValue, 1);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1)\n", result, negValue);

 // Round a positive value using a MidpointRounding value. 
 result = Math.Round(posValue, 1, MidpointRounding.ToEven);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                   result, posValue);
 result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)\n", 
                   result, posValue);

 // Round a negative value using a MidpointRounding value. 
 result = Math.Round(negValue, 1, MidpointRounding.ToEven);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                   result, negValue);
 result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)\n", 
                   result, negValue);
// The example displays the following output:
//        3.4 = Math.Round( 3.45, 1)
//       -3.4 = Math.Round(-3.45, 1)
//       
//        3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
//        3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
//       
//       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
Module Example
    Public Sub Main() 
        Dim posValue As Double = 3.45
        Dim negValue As Double = -3.45
        
        ' Round a positive and a negative value using the default.  
        Dim result As Double = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, posValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, negValue)
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       3.4 = Math.Round( 3.45, 1)
'       -3.4 = Math.Round(-3.45, 1)
'       
'       3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
'       3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'       
'       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Poznámky pro volající

Z důvodu ztráty přesnosti, která může být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou Round(Double, Int32, MidpointRounding) čárkou, v některých případech se může stát, že se metoda nezobrazí pro zaokrouhlení hodnot středního bodu podle zadání mode parametrem.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. To je znázorněno v následujícím příkladu, kde 2,135 se zaokrouhluje na 2,13 namísto 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. K tomu dochází, protože interně metoda value vynásobí 10číslicemia operace násobení v tomto případě utrpí ztrátu přesnosti.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[! Code-CSharpSystem. Math. Round # 3] [! Code-VBSystem. Math. Round # 3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

Viz také

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celé číslo a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, MidpointRounding mode);
public static double Round (double value, MidpointRounding mode);
static member Round : double * MidpointRounding -> double
Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parametry

value
Double Double Double Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.A double-precision floating-point number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Specifikace, která se má value zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.Specification for how to round value if it is midway between two other numbers.

Návraty

Nejbližší valuecelé číslo.The integer nearest value. Pokud value je uprostřed mezi dvěma celými čísly, jedna z nich je sudá a druhá lichá mode , pak určuje, který z těchto dvou je vrácen.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Všimněte si, že tato metoda Double vrátí místo celočíselného typu.Note that this method returns a Double instead of an integral type.

Výjimky

Poznámky

Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Pokud hodnota value argumentu je Double.NaN, vrátí Double.NaNmetoda.If the value of the value argument is Double.NaN, the method returns Double.NaN. Pokud value je Double.PositiveInfinity nebo ,Double.NegativeInfinitymetoda vrátíDouble.PositiveInfinity neboDouble.NegativeInfinityv uvedeném pořadí.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PříkladExample

Následující Round(Double) příklad zobrazuje hodnoty vracené metodou Round(Double, MidpointRounding) , ToEvenmetoda s mode Round(Double, MidpointRounding) AwayFromZeroargumentem a metoda s argumentem.modeThe following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                          12.7, 12.8, 12.9, 13.0 };
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Dim values() As Double = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                                 12.7, 12.8, 12.9, 13.0 }
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

Poznámky pro volající

Z důvodu ztráty přesnosti, která může být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou Round(Double, MidpointRounding) čárkou, v některých případech se může stát, že se metoda nezobrazí pro zaokrouhlení středních hodnot do nejbližší sudé celé číslo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. V následujícím příkladu vzhledem k tomu, že hodnota s plovoucí desetinnou čárkou nemá žádná konečná binární reprezentace, první volání Round(Double) metody s hodnotou 11,5 vrátí hodnotu 11 místo 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[! Code-CSharpSystem. Math. Round # 4] [! Code-VBSystem. Math. Round # 4][!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4]

Viz také

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet zlomkových číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

public:
 static double Round(double value, int digits);
public static double Round (double value, int digits);
static member Round : double * int -> double
Public Shared Function Round (value As Double, digits As Integer) As Double

Parametry

value
Double Double Double Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Počet desetinných číslic ve vrácené hodnotě.The number of fractional digits in the return value.

Návraty

Číslo nejbližší k value , které obsahuje počet zlomkových číslic, které digitsse rovnají.The number nearest to value that contains a number of fractional digits equal to digits.

Výjimky

digitsje menší než 0 nebo větší než 15.digits is less than 0 or greater than 15.

Poznámky

Hodnota digits argumentu může být v rozsahu od 0 do 15.The value of the digits argument can range from 0 to 15. Všimněte si, že 15 je maximální počet integrálních a zlomkových číslic, které Double typ podporuje.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Tato metoda používá výchozí konvenci MidpointRounding.ToEvenzaokrouhlení.This method uses the default rounding convention of MidpointRounding.ToEven. Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Pokud hodnota value argumentu je Double.NaN, vrátí Double.NaNmetoda.If the value of the value argument is Double.NaN, the method returns Double.NaN. Pokud value je Double.PositiveInfinity nebo ,Double.NegativeInfinitymetoda vrátíDouble.PositiveInfinity neboDouble.NegativeInfinityv uvedeném pořadí.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PříkladExample

Následující příklad zaokrouhlí dvojitou hodnotu o dvě zlomkové číslice na Double, které mají jednu zlomkovou číslici.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Poznámky pro volající

Z důvodu ztráty přesnosti, která může být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou Round(Double, Int32) čárkou, v některých případech se může stát, že se metoda nezobrazí pro zaokrouhlení středních hodnot do nejbližší sudá hodnota v digits desetinné pozici.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. To je znázorněno v následujícím příkladu, kde 2,135 se zaokrouhluje na 2,13 namísto 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. K tomu dochází, protože interně metoda value vynásobí 10číslicemia operace násobení v tomto případě utrpí ztrátu přesnosti.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[! Code-CSharpSystem. Math. Round # 2] [! Code-VBSystem. Math. Round # 2][!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2]

Viz také

Round(Double) Round(Double) Round(Double) Round(Double)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

public:
 static double Round(double a);
public static double Round (double a);
static member Round : double -> double
Public Shared Function Round (a As Double) As Double

Parametry

a
Double Double Double Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.A double-precision floating-point number to be rounded.

Návraty

Nejbližší acelé číslo.The integer nearest a. Pokud je desetinná komponenta a v polovině mezi dvěma celými čísly, jedna z nich je sudá a druhá lichá, vrátí sudé číslo.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Všimněte si, že tato metoda Double vrátí místo celočíselného typu.Note that this method returns a Double instead of an integral type.

Poznámky

Tato metoda používá výchozí konvenci MidpointRounding.ToEvenzaokrouhlení.This method uses the default rounding convention of MidpointRounding.ToEven. Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

Pokud hodnota a argumentu je Double.NaN, vrátí Double.NaNmetoda.If the value of the a argument is Double.NaN, the method returns Double.NaN. Pokud a je Double.PositiveInfinity nebo ,Double.NegativeInfinitymetoda vrátíDouble.PositiveInfinity neboDouble.NegativeInfinityv uvedeném pořadí.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

Počínaje Visual Basic 15,8 je výkon převodu typu Double-to-Integer optimalizován, Pokud předáte hodnotu vrácenou Round metodou do kterékoli z celočíselných funkcí pro převod, nebo pokud hodnota Round Double vrátí je automaticky převeden na celé číslo s možností stricted nastavenou na off.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. Tato optimalizace umožňuje, aby kód běžel rychleji – až dvakrát pro kód, který provádí velký počet převodů na celočíselné typy.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. Následující příklad znázorňuje tyto optimalizované převody:The following example illustrates such optimized conversions:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

PříkladExample

Následující příklad ukazuje zaokrouhlování na nejbližší celočíselnou hodnotu.The following example demonstrates rounding to the nearest integer value.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}
Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6
Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Poznámky pro volající

Z důvodu ztráty přesnosti, která může být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou Round(Double) čárkou, v některých případech se může stát, že se metoda nezobrazí pro zaokrouhlení středních hodnot do nejbližší sudé celé číslo.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. V následujícím příkladu vzhledem k tomu, že hodnota s plovoucí desetinnou čárkou nemá žádná konečná binární reprezentace, první volání Round(Double) metody s hodnotou 11,5 vrátí hodnotu 11 místo 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[! Code-CSharpSystem. Math. Round # 1] [! Code-VBSystem. Math. Round # 1][!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1]

Viz také

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Zaokrouhlí desítkovou hodnotu na zadaný počet zlomkových číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parametry

d
Decimal Decimal Decimal Decimal

Zaokrouhlované desetinné číslo.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Počet desetinných míst v návratové hodnotě.The number of decimal places in the return value.

Návraty

Číslo nejbližší k d , které obsahuje počet zlomkových číslic, které decimalsse rovnají.The number nearest to d that contains a number of fractional digits equal to decimals.

Výjimky

decimalsje menší než 0 nebo větší než 28.decimals is less than 0 or greater than 28.

Výsledek je mimo rozsah Decimal.The result is outside the range of a Decimal.

Poznámky

Hodnota decimals argumentu může být v rozsahu od 0 do 28.The value of the decimals argument can range from 0 to 28.

Tato metoda používá výchozí konvenci MidpointRounding.ToEvenzaokrouhlení.This method uses the default rounding convention of MidpointRounding.ToEven. Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

PříkladExample

Následující příklad zaokrouhlí desítkové hodnoty o dvě zlomkové číslice na hodnoty, které mají jednu zlomkovou číslici.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

Console.WriteLine(Math.Round(3.44m, 1)); 
Console.WriteLine(Math.Round(3.45m, 1)); 
Console.WriteLine(Math.Round(3.46m, 1)); 
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1)); 
Console.WriteLine(Math.Round(4.35m, 1)); 
Console.WriteLine(Math.Round(4.36m, 1)); 
// The example displays the following output:
//       3.4
//       3.4
//       3.5
//       
//       4.3
//       4.4
//       4.4
Public Module Example
   Sub Main()
      Console.WriteLine(Math.Round(3.44, 1)) 
      Console.WriteLine(Math.Round(3.45, 1)) 
      Console.WriteLine(Math.Round(3.46, 1)) 
      Console.WriteLine()
      
      Console.WriteLine(Math.Round(4.34, 1)) 
      Console.WriteLine(Math.Round(4.35, 1)) 
      Console.WriteLine(Math.Round(4.36, 1)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4
Viz také

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

Parametry

d
Decimal Decimal Decimal Decimal

Zaokrouhlované desetinné číslo.A decimal number to be rounded.

Návraty

Celé číslo, které d je nejblíže parametru.The integer nearest the d parameter. Pokud je desetinná komponenta d v polovině mezi dvěma celými čísly, jedna z nich je sudá a druhá lichá, je vráceno sudé číslo.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Všimněte si, že tato metoda Decimal vrátí místo celočíselného typu.Note that this method returns a Decimal instead of an integral type.

Výjimky

Výsledek je mimo rozsah Decimal.The result is outside the range of a Decimal.

Poznámky

Tato metoda používá výchozí konvenci MidpointRounding.ToEvenzaokrouhlení.This method uses the default rounding convention of MidpointRounding.ToEven. Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

PříkladExample

Následující příklad ukazuje Round(Decimal) metodu.The following example demonstrates the Round(Decimal) method. Všimněte si, Decimal že hodnota 4,5 se zaokrouhluje na 4 místo na 5, protože toto přetížení používá ToEven výchozí konvenci.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5
Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5
Viz také

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo a použije zadané konvence zaokrouhlení pro hodnoty středního bodu.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public static decimal Round (decimal d, MidpointRounding mode);
static member Round : decimal * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parametry

d
Decimal Decimal Decimal Decimal

Zaokrouhlované desetinné číslo.A decimal number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Specifikace, která se má d zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.Specification for how to round d if it is midway between two other numbers.

Návraty

Nejbližší dcelé číslo.The integer nearest d. Pokud d je uprostřed mezi dvěma čísly, jedna z nich je sudá a druhá lichá, mode pak určuje, který z těchto dvou je vrácen.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. Všimněte si, že tato metoda Decimal vrátí místo celočíselného typu.Note that this method returns a Decimal instead of an integral type.

Výjimky

Výsledek je mimo rozsah Decimal.The result is outside the range of a Decimal.

Poznámky

Informace o zaokrouhlených číslech s hodnotami střední hodnoty najdete v tématu hodnoty středního bodu a konvence zaokrouhlení .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Důležité

Při zaokrouhlování střední hodnoty algoritmu zaokrouhlení provádí test rovnosti.When rounding midpoint values, the rounding algorithm performs an equality test. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může Neočekávaná hodnota vrácená metodou.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Další informace najdete v tématu "Zaokrouhlení a přesnosti".For more information, see "Rounding and precision".

PříkladExample

Následující Round(Decimal) příklad zobrazuje hodnoty vracené metodou Round(Decimal, MidpointRounding) , ToEvenmetoda s mode Round(Decimal, MidpointRounding) AwayFromZeroargumentem a metoda s argumentem.modeThe following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value), 
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13
Viz také

Platí pro