この記事は機械翻訳されています。英語版の記事を表示するには、[英語] のチェック ボックスをオンにしてください。また、テキストにマウス ポインターを合わせると、ポップアップ ウィンドウに英語のテキストを表示することもできます。
翻訳
英語

Math.Round メソッド

 

公開日: 2016年10月

最も近い整数または指定した小数点以下の桁数に値を丸めます。

名前空間:   System
アセンブリ:  mscorlib (mscorlib.dll 内)

名前説明
System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal)

10 進値を最も近い整数値に丸めます。

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32)

10 進値を、指定した小数部の桁数に丸めます。

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32, MidpointRounding)

10 進値を、指定した小数部の桁数に丸めます。 値が 2 つの数値の中間にある場合にその値を丸める方法をパラメーターで指定します。

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, MidpointRounding)

10 進値を最も近い整数に丸めます。 値が 2 つの数値の中間にある場合にその値を丸める方法をパラメーターで指定します。

System_CAPS_pubmethodSystem_CAPS_staticRound(Double)

倍精度浮動小数点値を最も近い整数値に丸めます。

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32)

倍精度浮動小数点値を指定した小数部の桁数に丸めます。

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32, MidpointRounding)

倍精度浮動小数点値を指定した小数部の桁数に丸めます。 値が 2 つの数値の中間にある場合にその値を丸める方法をパラメーターで指定します。

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, MidpointRounding)

倍精度浮動小数点値を最も近い整数に丸めます。 値が 2 つの数値の中間にある場合にその値を丸める方法をパラメーターで指定します。

オーバー ロードの選択に関するガイダンスは、次を参照してください どのメソッドが呼び出し?

Decimal Math.Round(Decimald)

10 進数の値を最も近い整数に丸め、最も近い偶数に中間値を丸めます ()。

Double Math.Round(Doublea)

倍精度浮動小数点の値を最も近い整数に丸め、最も近い偶数に中間値を丸めます ()。

Decimal Math.Round(Decimald, Int32 decimals)

指定した小数部の桁の 10 進数値を四捨五入し、最も近い偶数に中間値を丸めます ()。

Double Math.Round(Doublevalue, Int32 digits)

倍精度浮動小数点の値を指定した小数点以下の桁数に丸め、最も近い偶数に中間値を丸めます ()。

Decimal Math.Round(Decimald, MidpointRounding mode)

10 進数の値を最も近い整数に丸めます、中間値を指定した丸め規約を使用して ()。

Double Math.Round(Doublevalue, MidpointRounding mode)

倍精度浮動小数点の値を最も近い整数に丸めます、中間値を指定した丸め方法を使用して ()。

Decimal Math.Round(Decimald, Int32 decimals, MidpointRounding mode)

指定した小数部の桁の 10 進数値を四捨五入し、中間値の指定した丸め規約を使用して ()。

Double Math.Round(Doublevalue, Int32 digits, MidpointRounding mode)

指定した小数部の桁の倍精度浮動小数点値に丸めます、中間値を指定した丸め方法を使用して ()。

これはパラメーターの完全な一覧、 Round メソッドです。 各オーバー ロードによって使用されるパラメーターでは、上記のオーバー ロードの構文を参照してください。

パラメーター

説明

d

Decimal

丸め対象の数です。

a

-または-

value

Double

丸め対象の倍精度浮動小数点数。

decimals

-または-

digits

Int32

戻り値の小数部の桁数。 Decimal 値、その範囲は 0 ~ 28 です。 Double 値、その範囲は 0 ~ 15 です。 15 は、最大数の整数部と小数の桁数がでサポートされていることに注意してください、 Double 型です。

既定値: 0 であり、整数に丸められます

mode

MidpointRounding

中間値の丸め処理を使用する規則を指定するフラグ。 参照してください 中間値と丸め処理を行う規則します。

既定値: MidpointRounding.ToEven

型: Decimal または Double, 丸め対象の値の型によって異なります。
同じ型の数値 d, 、a, 、または value, 、整数または指定した 10 進数のいずれかが丸みのあります。
参照してください 中間値と丸め処理を行う規則 中間値を持つ数値の丸め処理を行う方法についてです。

System_CAPS_warning警告

中間値を丸め、丸め処理を行うアルゴリズムは、等値テストを実行します。 問題のためのバイナリ表現と精度浮動小数点形式は、メソッドによって返される値を予想できないことができます。 詳細については、次を参照してください。 と精度の丸めします。

オーバー ロードの場合、 Double パラメーターを使用して呼び出された Double.NaN, 、メソッドが戻る Double.NaNします。 呼び出された場合 Double.PositiveInfinity または Double.NegativeInfinity, 、メソッドが返す Double.PositiveInfinity または Double.NegativeInfinity, 、それぞれします。

目的

Call

最も近い規則への丸め処理を使用して整数の数値を丸めます。

Round(Decimal)

または

Round(Double)

ラウンドを整数で、指定した数には、規則を丸めです。

Round(Decimal, MidpointRounding)

または

Round(Double, MidpointRounding)

最も近い規則への丸め処理を使用して指定した小数部の桁数に数値を丸めます。

Round(Decimal, Int32)

-または-

Round(Double, Int32)

指定して、指定した小数部の桁数に数値を丸め、規則を丸めです。

Round(Decimal, Int32, MidpointRounding)

または

Round(Double, Int32, MidpointRounding)

Round、 Single 値を指定した小数部の桁数に使用される指定された規則の丸め処理を行うと精度の損失を最小限に抑えることです。

変換、 Single に、 Decimal を呼び出すと Round(Decimal, Int32, MidpointRounding)です。

中間の値を丸める有効桁数の問題を最小限に抑えながらを指定した小数部の桁数の数値を丸めます。

「より大きいまたはにほぼ等しい」比較を実装する丸め処理を行うメソッドを呼び出します。 参照してください と精度の丸めします。

小数部の値を整数ラウンド小数部の値よりも大きいです。 たとえば、3.1 ~ 4 を丸められます。

Ceiling

小数部の値を整数に丸めですが、小数部の値より少ないです。 たとえば、3.9. ~ 3. を丸められます。

Floor

丸め処理を行うより精度の低いで最も近い値に指定された有効桁数で数値を変換する場合。 たとえば、使用、 Round(Double) 3.4 と 3.0 の値を丸める方法および Round(Double, Int32) 3.579 に 3.58 の値を丸める方法です。

中間値では、結果の最下位の数字の後の値は、2 つの数値の中間正確にです。 たとえば、3.47500 は、中間の値である場合に 2 つの小数点以下桁数が丸められます、7.500 に中間値を整数に丸め対象である場合です。 このような場合、最も近い値簡単に識別できません丸め方法なし。

Round メソッドは、中間値を処理するため 2 つの丸め処理を行う規則をサポートしています。

ゼロから離れる方向に丸め処理

中間値は、次の番号をゼロから離れる方向に丸められます。 3.75 が次の例では、3.8 に四捨五入 3.9 に 3.85 ラウンド-3.75 は-3.8 に丸められ、-3.85 は-3.9 に丸められます。 この形式の丸めがによって表される、 MidpointRounding.AwayFromZero 列挙体のメンバーです。

ゼロから離れる方向に丸め処理は、丸め処理の最もよく知られた形式です。

一番近い値に丸めるか、銀行型丸め方式

中間値は、最も近い偶数に丸められます。 たとえば、3.75 と 3.85 の両方になるように 3.8 と-3.75 と-3.85 の両方が-3.8 に丸めます。 この形式の丸めがによって表される、 MidpointRounding.ToEven 列挙体のメンバーです。

近似値に丸めは、財務や統計に関する操作に使用される丸め処理の標準的な形式です。 IEEE 標準 754、セクション 4 に準拠しています。 複数の丸め処理で使用すると、常に中間値を単一方向に丸めるによって引き起こされる丸めエラーが減少します。 場合によっては、この丸めエラーは重大なことがあります。

次の例は、常に中間値を単一方向に丸めるに起因するバイアスを示しています。 例では、配列の真の平均を計算する Decimal 数値を使用して、2 つの規則を使用して、配列内の値が丸められる場合、平均を計算します。 この例では真の平均と近似値に丸め処理を行う場合に、結果の平均は同じです。 ただし、ゼロから離れる方向丸め処理を行う場合に、結果の平均とは異なります.05 (または 3.6%) 真の平均です。

using System;

public class Example
{
   public static void Main()
   {
      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

既定では、 Round メソッドは最も近い規則への丸め処理を使用します。 次の表のオーバー ロード、 Round メソッドおよび丸め規約それぞれ使用します。

オーバー ロード

規則の丸め処理を行う

Round(Decimal)

ToEven

Round(Double)

ToEven

Round(Decimal, Int32)

ToEven

Round(Double, Int32)

ToEven

Round(Decimal, MidpointRounding)

によって決定される mode パラメーター。

Round(Double, MidpointRounding)

によって決定される mode パラメーター

Round(Decimal, Int32, MidpointRounding)

によって決定される mode パラメーター

Round(Double, Int32, MidpointRounding)

によって決定される mode パラメーター

丸め操作はを中間値かどうかを判断するため、 Round メソッドは元の値が 10 で切り捨てられます、乗算n, ここで、 n 戻り値で桁の小数部の桁数は、次の残りの値の小数部分が.5 以上であるかどうかを判断します。 これは、上の「テストに等しいかどうか」に等しいかどうか、および説明したようにテスト コードを少し修正、 Double リファレンス トピックでは、テストの浮動小数点値と等しいかどうかが問題のあるバイナリ表現と精度の浮動小数点の書式の問題があるためです。 つまり、(精度が失われる) が原因の .5 よりもやや少ない数値の任意の小数部は丸められませんから上位に向かって停止します。

この問題を説明する例を次に示します。 繰り返し、.1 に 11.0 を追加し、結果を最も近い整数に丸めます。 丸め方法に関係なく 11.5 は 12 に丸める必要があります。 ただしの例から出力として存在しません。 例では、"R"を使用して 標準数値書式指定文字列 表示には、値の完全な精度、および値が切り捨てられますが、繰り返しの追加中に有効桁数を失ったことを示しています、浮動小数点し、その値は実際に 11.499999999999998 します。 .499999999999998 が.5 より小さいであるために、値は、次に大きい整数に丸められません。 定数値 11.5 割り当てます場合に、例に示すもこの問題は発生しません、 Double 変数です。

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

中間の値を丸める有効桁数の問題は、次の条件が発生する可能性が最も高いです。

  • 小数部の値は、浮動小数点型のバイナリ形式で正確に表現できません。

  • ときに値が切り捨てられますが、1 つまたは複数の浮動小数点演算から計算されます。

  • 丸め対象の値がの場合、 Single ではなく、 Double または Decimalです。 詳細については、次のセクションを参照してください。 丸めと単精度浮動小数点値します。

操作を丸める有効桁数が不足しているが問題となる場合、次の操作を行います。

  • 丸め操作が丸くオーバー ロードを呼び出す場合、 Double の値を変更できます、 Double に、 Decimal 値し、丸くオーバー ロードを呼び出して、 Decimal 値の代わりにします。 ですが、 Decimal データ型は、表現の問題と精度の低下にもが、これらの問題は、はるかにまれです。

  • 丸め対象の値が期待どおりに中間値に近いかを判断する「ほぼ等しい」テストを実行するカスタムの丸め処理を行うアルゴリズムを定義します。 次の例、 RoundApproximate 小数部の値が十分に中間値が丸め処理を回避できる中間値の近くにあるかどうかを調査するメソッドです。 例の出力が示すように、前の例に示すように丸めの問題を修正します。

    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
    

Round メソッドには、型の引数を受け入れるオーバー ロードが含まれています。 DecimalDoubleです。 型の値を丸める方法がない Singleします。 渡した場合、 Single のオーバー ロードのいずれかの値、 Round メソッド、それにキャスト (c#) または変換 (Visual Basic) で、 Double, 、および対応する Round オーバー ロードを Double と呼ばれるパラメーター。 拡大変換ですが、多くの場合、必要、精度の損失次の例に示すようにします。 ときに、 Single に 16.325 の値が渡される、 Round メソッドされ、結果は 16.32 の 16.33 としない、期待される結果を最も近い規則への丸め処理を使用して、小数点以下 2 桁に丸められます。

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

この予期しない結果の変換で精度が失われる原因である、 Single 値を Doubleです。 その結果 Double 16.325000762939453 の値の中間値ではない 16.325 より大きい、上に常に丸められます。

多くの場合、例に示すように精度が失われる最小化したりキャストまたは変換すると、削除、 Single 値を Decimalです。 、これは縮小変換であるため、これが必要であるキャスト演算子を使用して、または変換メソッドを呼び出すことに注意してください。

次の例は、 Round(Decimal) メソッドです。 なお、 Decimal 4.5 の値は、このオーバー ロードは、既定値を使用するためは、5 ではなく 4 に丸められます。 ToEven 規則です。

using System;

class Example
{
   static void Main()
   {
      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

次の例では、最も近い整数に丸め処理を示します。

using System;

class Program
{
    static void Main()
    {
    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
    }
}

次の例では、2 桁の小数部を 1 つの桁の小数部を持つ値を含む 10 進数値を丸めます。

using System;

public class Sample {
   static void Main() {
      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

次の例では、2 桁の小数部を 1 つの桁の小数部を持つ doubles に double 型の値を丸めます。

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

によって返される値を表示する例を次の Round(Decimal) メソッドを Round(Decimal, MidpointRounding) メソッドを mode の引数 ToEven, 、および Round(Decimal, MidpointRounding) メソッドを mode の引数 AwayFromZeroです。

using System;

public class Example
{
   public static void Main()
   {
      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

によって返される値を表示する例を次の Round(Double) メソッドを Round(Double, MidpointRounding) メソッドを mode の引数 ToEven, 、および Round(Double, MidpointRounding) メソッドを mode の引数 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

次の例では、使用して、 Round メソッドを MidpointRounding 列挙します。

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

class Sample 
{
    public static void Main() 
    {
    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)

*/

次の例では、使用して、 Round(Double, Int32, MidpointRounding) メソッドを MidpointRounding 列挙します。

using System;

class Sample 
{
    public static void Main() 
    {
       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)

.NET Framework

せずオーバー ロード、 MidpointRounding でパラメーターがサポートされている: 4.5、4、3.5、3.0、2.0、1.1、1.0
でオーバー ロード、 MidpointRounding でパラメーターがサポートされている: 4.5、4、3.5、3.0、2.0

.NET Framework Client Profile

すべてのオーバー ロードがサポートされている 4、3.5 SP1。

汎用性のあるクラス ライブラリ

すべてのオーバー ロードがサポートされています。

Windows ストア アプリ用 .NET

すべてのオーバー ロードではサポートされて: Windows 8

トップに戻る
表示: