情報
要求されたトピックは次のとおりです。しかし、このトピックはこのライブラリには含まれていません。

Double 構造体

倍精度浮動小数点数を表します。

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>

Double 型で公開されるメンバーは以下のとおりです。

  名前説明
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETCompareTo(Double)このインスタンスと指定した倍精度浮動小数点数を比較し、このインスタンスの値が指定した倍精度浮動小数点数の値よりも小さいか、同じか、または大きいかを示す整数を返します。
パブリック メソッドXNA Framework によるサポートCompareTo(Object)このインスタンスと指定したオブジェクトを比較し、このインスタンスの値が指定したオブジェクトの値よりも小さいか、同じか、または大きいかを示す整数を返します。
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETEquals(Double)このインスタンスと指定した Double オブジェクトが同じ値を表しているかどうかを示す値を返します。
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETEquals(Object)対象のインスタンスが、指定したオブジェクトに等しいかどうかを示す値を返します。 (ValueType.Equals(Object) をオーバーライドします。)
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETGetHashCode対象のインスタンスのハッシュ コードを返します。 (ValueType.GetHashCode() をオーバーライドします。)
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETGetType現在のインスタンスの Type を取得します。 (Object から継承されます。)
パブリック メソッドXNA Framework によるサポートGetTypeCode Double 値型の TypeCode を返します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETIsInfinity指定した数値が負または正の無限大と評価されるかどうかを示す値を返します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETIsNaN指定された値が非数値 (NaN) かどうかを示す値を返します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETIsNegativeInfinity指定した数値が負の無限大と評価されるかどうかを示す値を返します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETIsPositiveInfinity指定した数値が正の無限大と評価されるかどうかを示す値を返します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETParse(String)数値の文字列形式を、等価の倍精度浮動小数点数に変換します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETParse(String, NumberStyles)数値の指定したスタイルでの文字列形式を、それと等価な倍精度浮動小数点数に変換します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETParse(String, IFormatProvider)指定したカルチャに固有の書式による数値の文字列形式を、それと等価な倍精度浮動小数点数に変換します。
パブリック メソッド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETParse(String, NumberStyles, IFormatProvider)指定したスタイルおよびカルチャ固有の書式での数値の文字列形式を、等価の倍精度浮動小数点数に変換します。
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETToString()このインスタンスの数値を、それと等価な文字列形式に変換します。 (ValueType.ToString() をオーバーライドします。)
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETToString(IFormatProvider)このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETToString(String)指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETToString(String, IFormatProvider)このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。
パブリック メソッド静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETTryParse(String, Double)数値の文字列形式を、等価の倍精度浮動小数点数に変換します。 戻り値は、変換が成功したか失敗したかを示します。
パブリック メソッド静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETTryParse(String, NumberStyles, IFormatProvider, Double)指定したスタイルおよびカルチャ固有の書式での数値の文字列形式を、等価の倍精度浮動小数点数に変換します。 戻り値は、変換が成功したか失敗したかを示します。
このページのトップへ

  名前説明
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETEquality指定した 2 つの Double 値が等しいかどうかを示す値を返します。
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETGreaterThan指定した Double 値が、指定したもう 1 つの Double 値より大きいかどうかを示す値を返します。
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETGreaterThanOrEqual指定した Double 値が、指定したもう 1 つの Double 値以上かどうかを示す値を返します。
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETInequality指定した 2 つの Double 値が等しくないかどうかを示す値を返します。
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETLessThan指定した Double 値が、指定したもう 1 つの Double 値より小さいかどうかを示す値を返します。
パブリック演算子静的メンバー汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETLessThanOrEqual指定した Double 値が、指定したもう 1 つの Double 値以下かどうかを示す値を返します。
このページのトップへ

  名前説明
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETEpsilonゼロより大きい最小の Double 値を表します。 このフィールドは定数です。
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETMaxValue Double の最大有効値を表します。 このフィールドは定数です。
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETMinValue Double の最小有効値を表します。 このフィールドは定数です。
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETNaN非数 (NaN) の値を表します。 このフィールドは定数です。
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETNegativeInfinity負の無限大を表します。 このフィールドは定数です。
パブリック フィールド静的メンバーXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETPositiveInfinity正の無限大を表します。 このフィールドは定数です。
このページのトップへ

  名前説明
明示的なインターフェイス実装プライベート メソッド汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETIComparable.CompareTo現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスの並べ替え順序での位置が、比較対象のオブジェクトと比べて前か、後か、または同じかを示す整数を返します。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToBooleanインフラストラクチャ。このメンバーの説明については、IConvertible.ToBoolean のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToByteインフラストラクチャ。このメンバーの説明については、IConvertible.ToByte のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToCharインフラストラクチャ。この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToDateTimeインフラストラクチャ。この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToDecimalインフラストラクチャ。このメンバーの説明については、IConvertible.ToDecimal のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToDoubleインフラストラクチャ。このメンバーの説明については、IConvertible.ToDouble のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToInt16インフラストラクチャ。このメンバーの説明については、IConvertible.ToInt16 のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToInt32インフラストラクチャ。このメンバーの説明については、IConvertible.ToInt32 のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToInt64インフラストラクチャ。このメンバーの説明については、IConvertible.ToInt64 のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToSByteインフラストラクチャ。このメンバーの説明については、IConvertible.ToSByte のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToSingleインフラストラクチャ。このメンバーの説明については、IConvertible.ToSingle のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToTypeインフラストラクチャ。このメンバーの説明については、IConvertible.ToType のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToUInt16インフラストラクチャ。このメンバーの説明については、IConvertible.ToUInt16 のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToUInt32インフラストラクチャ。このメンバーの説明については、IConvertible.ToUInt32 のトピックを参照してください。
明示的なインターフェイス実装プライベート メソッドXNA Framework によるサポートIConvertible.ToUInt64インフラストラクチャ。このメンバーの説明については、IConvertible.ToUInt64 のトピックを参照してください。
このページのトップへ

Double の値型は負 1.79769313486232e308 から正の 1.79769313486232e308 まで、正または負の場合、PositiveInfinityNegativeInfinityと非数 (NaN) の値と倍精度の 64 ビットの数を表します。 または、非常に小さい (キログラムの、分子の量 (グローバル) から別の太陽系への間隔など) (Planet またはギャラクシーの間隔などの非常によく不適切な値を表すことを前提とします Double の型はバイナリ浮動小数点演算の IEC の 60559:1989 (IEEE 754) 標準に従います。

このトピックは、次のセクションで構成されています。

浮動小数点表現および精度

Double のデータ型は、次の表に示す 64 ビット バイナリ形式で倍精度浮動小数点値を格納する:

パーツ

ビット

Significand または仮数

0-51

指数

52-62

0 記号 (= 正、負) = 1

63

、小数部分でが正確にある小数値を表す NOT (1/3 または Math.PIなど) ため、バイナリ分数は、小数値を表現できません。 たとえば、10 進小数として .1 で正確に表す 1/10 パターンは「0011 "にバイナリ分数として .001100110011 で表され、無限大に繰り返します。 この場合、浮動小数点値を表す数値の不適切な表現を提供します。 元の浮動小数点値の追加数値演算を実行するには、精度の不足を強化する傾向があります。 たとえば、.1 に 10 を乗算し、.1 ~ .1 の 9 回を追加した結果を比較する場合は、8 個以上の操作を含むため、この追加を生みましたよりも正確な結果を参照します。 これを必要に応じて Double 型でサポートされるは 17 桁の有効桁数をすべて表示する「R」 標準の数値書式指定文字列を使用して Double 2 個の値を表示する場合にのみ、このバランスが明確であることに注意してください。


using System;

public class Example
{
   public static void Main()
   {
      Double value = .1;
      Double result1 = value * 10;
      Double result2 = 0;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".1 * 10:           {0:R}", result1);
      Console.WriteLine(".1 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989


数字が小数のバイナリ値と正確に表すことができないため、浮動小数点数の実数のみ近づけないできます。

すべての浮動小数点数は、正確に浮動小数点値を実数をどのように近づけるかを有効桁数の制限があります。最大 17 の数値が内部的に残されていますが、Double 値に正確に 15 個の 10 進数があります。 したがって、浮動小数点値を変更するには、浮動小数点演算の精度が含まれない場合があることを意味します。 具体的な例を次に示します。 このクラスは、非常に大きな浮動小数点値を定義し、Double.Epsilon と 1 quadrillion の製品を追加します。 ただし、製品が元の浮動小数点値を変更するには小さすぎる。 その中で有効桁数は製品のほとんどの有効桁数が 1.であり、1000 分の 1 です。-312


using System;

public class Example
{
   public static void Main()
   {
      Double value = 123456789012.34567;
      Double additional = Double.Epsilon * 1e12;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-312 = 123456789012.346


浮動小数点数の制限された精度で複数の結果があります:

  • 特定の桁数において等しい 2 つの浮動小数点数が、最下位バイトが異なっているために、等価でないと評価される場合があります。 次の例では、一連の数字をまとめて追加され、合計は予期された合計と比較されます。 2 種類の値が同一のように見えますが Equals のメソッドの呼び出しはないことを示します。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 };
          Double result = 27.64;
          Double total = 0;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (36.64) does not equal the total (36.64).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.639999999999997) does not equal the total (27.64).   
    
    
    

    Double 値 2 のすべての有効桁数を表示するに {0}{1} から {0:R}{1:R}Console.WriteLine(String, Object, Object) のステートメントの書式項目を変更した場合、値 2 が加算演算中に精度に等しくないことが明確になります。 この場合、問題は比較を実行する前に、目的の精度で Double 値を丸めますするに Math.Round(Double, Int32) のメソッドを呼び出すことで解決できます。

  • バイナリ浮動小数点数が 10 進数に表示されない場合があります。そのため、10 進数を使用する浮動小数点数を使用する比較演算や算術は同じ結果が生じる場合があります。 前の例では、バージョン .1 に 10 を乗算し、.1 回で追加した結果を表示することによってこれを示しました。

    小数値の数値演算の精度がある場合、Double の型ではなく Decimal を使用できます。 Int64 または UInt64 の型の範囲外整数値を持つ数値演算の精度がある場合、BigInteger 型を使用します。

  • 値は浮動小数点数が複雑な場合をラウンドトリップさせる場合があります。 値はラウンド トリップに浮動小数点数の操作が別のフォームに元の浮動小数点数を変換する場合、逆の操作変換し、変換されたフォームと呼ばれ、最終的な浮動小数点数は、元の浮動小数点数と等価です。 最下位の桁数が 1 つ以上失われるか、または変更された場合は、ラウンドトリップが失敗します。 次の例では、Double 3 個の値を文字列に変換し、ファイルに格納されます。 ただし、出力結果が示すように値が同一にあっても、元の値が元の値に等しくなります。

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 <> 2.17821782178218
    //       0.333333333333333 <> 0.333333333333333
    //       3.14159265358979 <> 3.14159265358979
    
    
    

    この場合、値は Double 値の完全な精度を維持するには、「R」 標準の数値書式指定文字列 を使用して、次の例に示すように正常にラウンド トリップできます。

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
    
    
  • Single 値に Double 値よりも精度があります。 表面上は同等の Double に変換する Single 値は、精度の違いに Double 値ではありません。 次の例では、同一の除算演算の結果は DoubleSingle 値に割り当てられます。 Single 値が Doubleにキャストされた後、値 2 の比較は、等しくないことを示します。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    
    

    値の両方に、同じ精度がこの問題を回避するには、DoubleSingle のデータ型の代わりに使用することも、Round のメソッドを使用します。

また、Double 値を使用した算術演算および代入演算の結果はプラットフォームによって多少異なる場合がありますが、これは Double 型の精度の低下によるものです。 たとえば、.NET Framework の 32 ビット版と 64 ビット版とでは、Double 型のリテラル値を代入した結果が異なる場合があります。 次の例では、リテラル値 -4.42330604244772E-305 と値 -4.42330604244772E-305 の変数が Double 変数に代入された場合の差を示しています。 このクラスの Parse(String) メソッドの結果は、誤差の影響を受けていない点に注目してください。


double value = -4.42330604244772E-305;

double fromLiteral = -4.42330604244772E-305;
double fromVariable = value;
double fromParse = Double.Parse("-4.42330604244772E-305");

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral);
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable);
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse);      
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305      


等価性のテスト

考慮する場合、Double 値 2 が同一の値を表す必要があります。 ただし、の値間の精度の差、または 1 のいずれかまたは両方の値に応じて、精度、最小限の有効桁数の違いに等しくない同一の人出であるとともに必要な浮動小数点値。 その結果、または呼び出し 2 二つの値が等しい Double 値 2 は、yield 予期しない結果の間の関係を確認 CompareTo のメソッドにかどうかを確認 Equals のメソッドの呼び出し。 これが 2 番目には 17 ですが、1 番目には 15 桁の有効桁数があるため Double 2 のように等しい値が等しくないする次の例で、顕著です。


using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False


異なるコード パスに従ってさまざまな方法で処理され、計算値は、等しくない検証します。 次の例では、Double 値 1 は 2 乗され、元の値を復元するために、値が計算されます。 元の値を復元するために、結果の値が 3.51 による除算が呼び出される前に秒 Double は 3.51 ずつ増加し、2 乗されます。 2 種類の値が同一のように見えますが Equals(Double) のメソッドの呼び出しは等しくないことを示します。 「R」標準書式指定文字列を使用して、それぞれの double 値の有効桁数を表示する結果文字列を返すと、2 番目の値は .0000000000001、1 番目のほどであることを示します。


using System;

public class Example
{
   public static void Main()
   {
      double value1 = 100.10142;
      value1 = Math.Sqrt(Math.Pow(value1, 2));
      double value2 = Math.Pow(value1 * 3.51, 2);
      value2 = Math.Sqrt(value2) / 3.51;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//    100.10142 = 100.10142: False
//    
//    100.10142 = 100.10141999999999


比較の結果に影響を与えるために精度が見込まれる場合 Equals または CompareTo のメソッドを呼び出して、次の代わりに導入する:

  • 値の両方に、同じ精度があることを確認するに Math.Round のメソッドを呼び出します。 次の例では、2 桁の小数部値が同じになるようにこの方法を使用するには、前の例を修正します。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double value1 = .333333333333333;
          double value2 = 1.0/3;
          int precision = 7;
          value1 = Math.Round(value1, precision);
          value2 = Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    
    
    

    精度の問題がまだ中点値を丸めるだけでなく、メモです。 詳細については、Math.Round(Double, Int32, MidpointRounding) メソッドのトピックを参照してください。

  • 同等ではなくおおよその等価をテストします。 これは、2 種類の値も等しくなるように定義するか、小さい値が大きい値から分岐できる相対的な量を異なるできますが、絶対量のどちらかを定義する必要があります。

    Caution メモ注意

    Double.Epsilon は、Double 値 2 の間の絶対単位として等価をテストするときに使用します。ただし、Double.Epsilon を追加またはから描画できる最小有効値がゼロである Double を測定します。 Double ほとんどの正の数で、負のな値については、Double.Epsilon の値を検出するには小さすぎる。 したがって、ゼロでない値を除き、等価性のテストの使用はお勧めしません。

    次の例では、値 2 との相対的な相違点をテストする IsApproximatelyEqual のメソッドを定義するには、次の方法を使用します。 また、IsApproximatelyEqual のメソッドと Equals(Double) のメソッドの呼び出しの結果の比較を示しています。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000000001));   
       }
    
       static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
    
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 0.99999999999999989: False
    //       1 is approximately equal to 0.99999999999999989: True
    
    
    

浮動小数点値と例外

ゼロ除算などのオーバーフローまたは無効な操作の場合に例外をスローする整数型の操作とは異なり、浮動小数点値の操作は例外をスローしません。 代わりに、例外的な状況は、浮動小数点演算の結果は、正の無限大、負の無限大、または NaN (非数 (NaN) です:

  • 浮動小数点演算の結果は、変換先の形式に小さすぎると、結果はゼロです。 これを次の例に示すように、2 種類の非常に小さい数値が増えたときに発生します。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
       }
    }
    // The example displays the following output:
    //       1.16328759815342E-225 * 9.1642346778E-175 = 0
    //       0 = 0: True
    
    
    
  • 浮動小数点演算の結果の大きさは先の形式の範囲を超えると、操作の結果が結果の符号に応じて PositiveInfinity または NegativeInfinityです。 Double.MaxValue オーバーフローする演算の結果は次の例のように、オーバーフロー Double.MinValueNegativeInfinityで実行する操作の PositiveInfinityとなります。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Double.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Double.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    
    

    PositiveInfinity は 正の被除数で除算、負のな被除数で除算の NegativeInfinity の結果になります。

  • 浮動小数点演算が無効な場合、演算結果は NaN になります。 たとえば、NaN は次の操作によってします:

  • 無効な入力に浮動小数点演算。 たとえば、負の値を持つ Math.Sqrt のメソッドを呼び出すと、NaNを返します。同様に、1 を超える正または負の 1 未満の値の Math.Acos のメソッドを呼び出します。

  • 値が Double.NaNである引数の操作。

浮動小数点機能

Double 構造体および関連する型は、次の領域にアクションを実行するメソッドを提供し、T:

  • 値の比較 値 2 の関係をできますかどうかを確認するに Equals のメソッド Double 2 の値の等価性を確認するために、CompareTo のメソッドを呼び出す。

    Double 構造体も比較演算子の完全なセットをサポートします。 たとえば、等値演算子または非等値をテストしたり、1 一方の値が他方の値以上かどうかを確認します。 オペランドの 1 つが Double以外の数値型は、比較する前の Double に変換されます。

    Caution メモ注意

    精度の違いにより、あると想定する Double 値 2 は、比較の結果に影響を与える、等しくないなる可能性があります。 Double 値 2 の比較の詳細については、" 等価性のテスト "を参照してください。

    これらの特殊な値をテストするに IsNaNIsInfinityIsPositiveInfinityIsNegativeInfinity のメソッドを呼び出すことができます。

  • 算術演算 共通の算術演算などは、加算、減算、Double メソッドのではなく、言語コンパイラおよび Common Intermediate Language (CIL) の手順で乗算、除算、実装されます。 数値演算のオペランドの 1 つが Double以外の数値型である場合、演算が実行される前の Double に変換されます。 演算の結果も Double 値です。

    そのほかの数値演算は static (Visual Basic のShared) メソッドを呼び出して System.Math クラスで実行できます。 これは演算 (Math.AbsMath.SignMath.Sqrtなど)、ジオメトリ (Math.CosMath.Sinなど)、および" Calculus "で使用される追加メソッドが含まれます (Math.Logなど)。

    また Double 値の個々のビットを処理できます。 BitConverter.DoubleToInt64Bits のメソッドは、64 ビットの整数の Double 値のビット パターンを保持します。 BitConverter.GetBytes(Double) メソッドは、バイト配列のビット パターン。

  • 丸み 丸めることがよく使用されます。に浮動小数点表現の問題による値と精度の相違点の影響を軽減する方法。 Math.Round のメソッドを呼び出して丸めます。Double 値を指定できます。

  • 書式設定 文字列形式への ToString メソッドを呼び出すか、複合書式指定機能を使用して、Double 値を変換できます。 情報の書式指定文字列に浮動小数点の値の文字列形式がどのように管理するか、標準の数値書式指定文字列カスタム数値書式指定文字列 のトピックを参照してください。

  • 文字列の解析 Double 値に Parse または TryParse のメソッドを呼び出して、浮動小数点値の文字列形式に変換できます。 解析操作が失敗した場合、Parse のメソッドは例外を、単一 TryParse メソッドの戻り falseスローします。

  •   Double 構造体は、2 種類の標準的な .NET Framework のデータ型の変換をサポートする IConvertible インターフェイスに明示的なインターフェイスの実装を提供します。 言語コンパイラは、Double 値への他のすべての標準数値型の値への暗黙の型変換をサポートしています。 Double への標準数値型の値の変換は拡大変換で、キャスト演算子または変換メソッドのユーザーを必要としません。

    ただし、Int64 変換、Single 値は精度が低下する可能性があります。 次の表は、これらの型の精度の違いを示します。:

    Type

    最大の精度

    内部精度

    Double

    15

    17

    Int64

    19 桁の 10 進数

    19 桁の 10 進数

    Single

    7 桁の 10 進数

    9 桁の 10 進数

    精度の問題が最も頻繁に Double 値に変換されます Single 値に影響します。 次の例では、同一の除算演算によって生成された値 2 は値の 1 つが Doubleに変換される単精度の浮動小数点値で、等しくありません。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value = .1;
          Double result1 = value * 10;
          Double result2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             result2 += value;
    
          Console.WriteLine(".1 * 10:           {0:R}", result1);
          Console.WriteLine(".1 Added 10 times: {0:R}", result2);
       }
    }
    // The example displays the following output:
    //       .1 * 10:           1
    //       .1 Added 10 times: 0.99999999999999989
    
    
    

Double の使用方法については、次のコード例を参照してください。


	// The Temperature class stores the temperature as a Double
	// and delegates most of the functionality to the Double
	// implementation.
	public class Temperature : IComparable, IFormattable 
    {
		// IComparable.CompareTo implementation.
		public int CompareTo(object obj) {
            if (obj == null) return 1;

			Temperature temp = obj as Temperature;
            if (obj != null) 
				return m_value.CompareTo(temp.m_value);
			else
     			throw new ArgumentException("object is not a Temperature");	
		}

		// IFormattable.ToString implementation.
		public string ToString(string format, IFormatProvider provider) {
			if( format != null ) {
				if( format.Equals("F") ) {
					return String.Format("{0}'F", this.Value.ToString());
				}
				if( format.Equals("C") ) {
					return String.Format("{0}'C", this.Celsius.ToString());
				}
			}

			return m_value.ToString(format, provider);
		}

		// Parses the temperature from a string in the form
		// [ws][sign]digits['F|'C][ws]
		public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
			Temperature temp = new Temperature();

			if( s.TrimEnd(null).EndsWith("'F") ) {
				temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
			}
			else if( s.TrimEnd(null).EndsWith("'C") ) {
				temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
			}
			else {
				temp.Value = Double.Parse(s, styles, provider);
			}

			return temp;
		}

		// The value holder
		protected double m_value;

		public double Value {
			get {
				return m_value;
			}
			set {
				m_value = value;
			}
		}

		public double Celsius {
			get {
				return (m_value-32.0)/1.8;
			}
			set {
				m_value = 1.8*value+32.0;
			}
		}
	}


.NET Framework

サポート対象 : 4.5.2、4.5.1、4.5、4、3.5、3.0、2.0、1.1、1.0

.NET Framework Client Profile

サポート対象 : 4、3.5 SP1

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

サポート対象 : 汎用性のあるクラス ライブラリ

Windows ストア アプリ用 .NET

サポート対象 : Windows 8

Windows Phone アプリ用 .NET

サポート対象 : Windows Phone 8、Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (サーバー コア ロールはサポート対象外), Windows Server 2008 R2 (SP1 以降でサーバー コア ロールをサポート。Itanium はサポート対象外)

.NET Framework では、各プラットフォームのすべてのバージョンはサポートしていません。サポートされているバージョンについては、「.NET Framework システム要件」を参照してください。

この型のすべてのメンバーはスレッド セーフです。 インスタンスの状態を変更するように見えるメンバーは、実際には新しい値を使用して初期化された新しいインスタンスを返します。 他の型と同じように、確実なスレッド セーフを実現するには、この型のインスタンスを含む共有変数の読み取りと書き込みをロックによって保護する必要があります。

Caution メモ注意

この型のインスタンスのバイナリ表現は大きすぎて 1 回の分割不可能操作に割り当てられないため、このインスタンスを割り当てることはすべてのハードウェア プラットフォームでスレッド セーフではありません。

コミュニティの追加

表示:
© 2014 Microsoft