Double 構造体

定義

名前空間:

System

アセンブリ:

System.Runtime.dll

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

public value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>

public readonly struct Double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>

type double = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<double>
    interface ISpanFormattable
    interface ISpanParsable<double>
    interface IAdditionOperators<double, double, double>
    interface IAdditiveIdentity<double, double>
    interface IBinaryFloatingPointIeee754<double>
    interface IBinaryNumber<double>
    interface IBitwiseOperators<double, double, double>
    interface IComparisonOperators<double, double, bool>
    interface IEqualityOperators<double, double, bool>
    interface IDecrementOperators<double>
    interface IDivisionOperators<double, double, double>
    interface IIncrementOperators<double>
    interface IModulusOperators<double, double, double>
    interface IMultiplicativeIdentity<double, double>
    interface IMultiplyOperators<double, double, double>
    interface INumber<double>
    interface INumberBase<double>
    interface ISubtractionOperators<double, double, double>
    interface IUnaryNegationOperators<double, double>
    interface IUnaryPlusOperators<double, double>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<double>
    interface IExponentialFunctions<double>
    interface IFloatingPointConstants<double>
    interface IFloatingPoint<double>
    interface ISignedNumber<double>
    interface IFloatingPointIeee754<double>
    interface IHyperbolicFunctions<double>
    interface ILogarithmicFunctions<double>
    interface IPowerFunctions<double>
    interface IRootFunctions<double>
    interface ITrigonometricFunctions<double>
    interface IMinMaxValue<double>

Public Structure Double
Implements IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double), IUtf8SpanParsable(Of Double)

継承

Object

ValueType

Double

実装

IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanParsable<Double> ISpanParsable<TSelf> IAdditionOperators<Double,Double,Double> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Double,Double> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Double> IBinaryNumber<Double> IBinaryNumber<TSelf> IBitwiseOperators<Double,Double,Double> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Double,Double,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<TSelf> IFloatingPointConstants<Double> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Double> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Double> IHyperbolicFunctions<TSelf> IIncrementOperators<Double> IIncrementOperators<TSelf> ILogarithmicFunctions<Double> ILogarithmicFunctions<TSelf> IMinMaxValue<Double> IModulusOperators<Double,Double,Double> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Double,Double> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Double,Double,Double> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Double> INumber<TSelf> INumberBase<Double> INumberBase<TSelf> IPowerFunctions<Double> IPowerFunctions<TSelf> IRootFunctions<Double> IRootFunctions<TSelf> ISignedNumber<Double> ISignedNumber<TSelf> ISubtractionOperators<Double,Double,Double> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Double> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Double,Double> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Double,Double> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<TSelf>

例

次のコード例は、 の使用方法 Doubleを示しています。

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double 
// implementation.
public ref class Temperature: public IComparable, public IFormattable
{
   // IComparable.CompareTo implementation.
public:
   virtual int CompareTo( Object^ obj )
   {
      if (obj == nullptr) return 1;
      
      if (dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException( "object is not a Temperature" );
   }

   // IFormattable.ToString implementation.
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         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]
   static Temperature^ Parse( String^ s, NumberStyles styles, IFormatProvider^ provider )
   {
      Temperature^ temp = gcnew Temperature;

      if ( s->TrimEnd(nullptr)->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      if ( s->TrimEnd(nullptr)->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      {
         temp->Value = Double::Parse( s, styles, provider );
      }
      return temp;
   }

protected:
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }

      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }

      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

// 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;
        }
    }
}

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () = (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

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

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        elif s.TrimEnd(null).EndsWith "'C" then
            temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        else
            temp.Value <- Double.Parse(s, styles, provider)
        temp

    interface IComparable with
        // IComparable.CompareTo implementation.
        member this.CompareTo(obj: obj) =
            match obj with 
            | null -> 1
            | :? Temperature as temp ->
                this.Value.CompareTo temp.Value
            | _ ->
                invalidArg "obj" "object is not a Temperature"

    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd(Nothing).EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

注釈

値型はDouble、負の 1.79769313486232e308 から正の 1.79769313486232e308 までの範囲の値を持つ倍精度 64 ビット数値を表し、正または負のゼロ 、、PositiveInfinityNegativeInfinity、および数値 (NaN) は表しません。 これは、非常に大きい値 (惑星や銀河間の距離など) または非常に小さい値 (1kg 単位の物質の分子質量など) を表し、多くの場合、不正確な値 (地球から別の太陽系までの距離など) を表すことを目的としています。 この型は Double 、二項浮動小数点演算の IEC 60559:1989 (IEEE 754) 標準に準拠しています。

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

• 浮動小数点表現と精度

• 等価性のテスト

• 浮動小数点値と例外

• 型変換と Double 構造体

• 浮動小数点機能

Floating-Point 表現と精度

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

パーツ	Bits
仮数または仮数	0-51
指数	52-62
符号 (0 = 正、1 = 負)	63

小数部が一部の小数部の値 (1/3 や など) を正確に表すことができないのと Math.PI同様に、二項分数では一部の小数部を表すことができません。 たとえば、1/10 は 10 進数の小数部として .1 で正確に表され、.001100110011 で二項分数として表され、パターン "0011" は無限大に繰り返されます。 この場合、浮動小数点値は、それが表す数値の不正確な表現を提供します。 元の浮動小数点値に対して追加の算術演算を実行すると、多くの場合、精度の不足が増加する傾向があります。 たとえば、.1 を 10 で乗算し、.1 を .1 に 9 回加算した結果を比較すると、さらに 8 つの演算が関係しているため、精度の低い結果が得られることがわかります。 この不一貫性は、"R" 標準の数値書式指定文字列を使用して 2 つのDouble値を表示する場合にのみ明らかになります。必要に応じて、型でDoubleサポートされている有効桁数の 17 桁すべてが表示されます。

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

let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
    result2 <- result2 + value

printfn $".1 * 10:           {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

Module Example
   Public Sub Main()
      Dim value As Double = .1
      Dim result1 As Double = value * 10
      Dim result2 As Double
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".1 * 10:           {0:R}", result1)
      Console.WriteLine(".1 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .1 * 10:           1
'       .1 Added 10 times: 0.99999999999999989

一部の数値は小数部の二項値として正確に表すことができないため、浮動小数点数は実数のみを近似できます。

すべての浮動小数点数には有効桁数も限られています。これにより、浮動小数点値が実数に近似する精度も決定されます。 値の Double 有効桁数は最大 15 桁ですが、内部的には最大 17 桁が維持されます。 つまり、浮動小数点演算によっては、浮動小数点値を変更する精度が不足している可能性があります。 具体的な例を次に示します。 非常に大きな浮動小数点値を定義し、 と 1 つの四分の一の Double.Epsilon 積を追加します。 ただし、この製品は小さすぎて元の浮動小数点値を変更するには大きすぎます。 その最下位桁は 1000 分の 1 ですが、製品の最も重要な数字は 10 ^{から 309 です}。

using System;

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

open System

let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

Module Example
   Public Sub Main()
      Dim value As Double = 123456789012.34567
      Dim additional As Double = Double.Epsilon * 1e15
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional)
   End Sub
End Module
' The example displays the following output:
'   123456789012.346 + 4.94065645841247E-309 = 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).
  

  let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ]
  let result = 27.64
  let total = List.sum values
  
  if total.Equals result then
      printfn "The sum of the values equals the total."
  else
      printfn $"The sum of the values ({total}) does not equal the 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).
  

  Module Example
     Public Sub Main()
        Dim values() As Double = { 10.0, 2.88, 2.88, 2.88, 9.0 }
        Dim result As Double = 27.64
        Dim total As Double
        For Each value In values
           total += value
        Next
        If total.Equals(result) Then
           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) 
        End If     
     End Sub
  End Module
  ' 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).
  

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

• 浮動小数点数を使用する算術演算または比較演算では、10 進数を使用すると同じ結果が得られない場合があります。これは、2 進浮動小数点数が 10 進数と等しくない可能性があるためです。 前の例では、.1 に 10 を乗算し、.1 を加算した結果を表示しています。

  小数部の値を持つ数値演算の精度が重要な場合は、 型ではなく をDecimalDouble使用できます。 または UInt64 型の範囲を超える整数値を持つ数値演算のInt64精度が重要な場合は、 型をBigInteger使用します。

• 浮動小数点数が関係している場合、値はラウンドトリップしない可能性があります。 演算が元の浮動小数点数を別の形式に変換し、逆演算によって変換されたフォームが浮動小数点数に変換され、最終的な浮動小数点数が元の浮動小数点数と等しくない場合、値はラウンドトリップと言われます。 変換で 1 つ以上の最下位桁数が失われたり変更されたりするため、ラウンド トリップが失敗する可能性があります。 次の例では、3 つの Double 値が文字列に変換され、ファイルに保存されます。 ただし、出力に示されているように、値が同一のように見えても、復元された値は元の値と等しくありません。

  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
  

  open System
  open System.IO
  
  let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]
  
  using (new StreamWriter(@".\Doubles.dat")) (fun sw ->
      for i = 0 to values.Length - 1 do
          sw.Write(string values[i])
          if i <> values.Length - 1 then
              sw.Write "|")
  
  using (new StreamReader(@".\Doubles.dat")) (fun sr ->
      let temp = sr.ReadToEnd()
      let tempStrings = temp.Split '|'
  
      let restoredValues =
          [ for i = 0 to tempStrings.Length - 1 do
                Double.Parse tempStrings[i] ]
  
      for i = 0 to values.Length - 1 do
          printfn $"""{values[i]} {if values[ i ].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}""")
  
  // The example displays the following output:
  //       2.17821782178218 <> 2.17821782178218
  //       0.333333333333333 <> 0.333333333333333
  //       3.14159265358979 <> 3.14159265358979
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write(values(ctr).ToString())
           If ctr <> values.Length - 1 Then sw.Write("|")
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.17821782178218 <> 2.17821782178218
  '       0.333333333333333 <> 0.333333333333333
  '       3.14159265358979 <> 3.14159265358979
  

  この場合、次の例に示すように、"G17" 標準の数値書式指定文字列 を使用して値を Double 丸めることができます。

  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:G17}{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
  

  open System
  open System.IO
  
  let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]
  
  using (new StreamWriter(@".\Doubles.dat")) (fun sw -> 
      for i = 0 to values.Length - 1 do
          sw.Write $"""{values[i]:G17}{if i < values.Length - 1 then "|" else ""}""")
  
  using (new StreamReader(@".\Doubles.dat")) (fun sr ->
      let temp = sr.ReadToEnd()
      let tempStrings = temp.Split '|'
      
      let restoredValues = 
        [ for i = 0 to tempStrings.Length - 1 do
              Double.Parse tempStrings[i] ]
  
      for i = 0 to values.Length - 1 do
          printfn $"""{restoredValues[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {values[i]}""")
  
  // The example displays the following output:
  //       2.17821782178218 = 2.17821782178218
  //       0.333333333333333 = 0.333333333333333
  //       3.14159265358979 = 3.14159265358979
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write("{0:G17}{1}", values(ctr), 
                    If(ctr < values.Length - 1, "|", ""))
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.17821782178218 = 2.17821782178218
  '       0.333333333333333 = 0.333333333333333
  '       3.14159265358979 = 3.14159265358979
  

重要

値と共に Double 使用すると、"R" 書式指定子が元の値を正常にラウンドトリップできない場合があります。 値が正常にラウンドトリップされるように Double するには、"G17" 書式指定子を使用します。

• Single 値の精度は値よりも Double 小さくなります。 Single一見等価Doubleに変換される値は、多くの場合、精度のDouble違いのために値と等しくありません。 次の例では、同一の除算操作の結果が と Single の値にDouble割り当てられます。 値が 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
  

  open System
  
  let value1 = 1. / 3.
  let sValue2 = 1f /3f
  
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1/3
        Dim sValue2 As Single = 1/3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

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

さらに、値を持つ Double 算術演算と代入演算の結果は、型の精度 Double が失われるため、プラットフォームによって若干異なる場合があります。 たとえば、リテラルDouble値を割り当てた結果は、.NET Frameworkの 32 ビット バージョンと 64 ビット バージョンで異なる場合があります。 次の例は、リテラル値 -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

let value = -4.42330604244772E-305

let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"

printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// 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

Dim value As Double = -4.42330604244772E-305

Dim fromLiteral As Double = -4.42330604244772E-305
Dim fromVariable As Double = value
Dim fromParse As Double = 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

等価性のテスト

等しいと見なすには、2 つの Double 値が同じ値を表す必要があります。 ただし、値間の精度の違い、または一方または両方の値による精度の損失により、同一であると予想される浮動小数点値は、最下位の桁数の違いにより等しくないことがよくあります。 その結果、 メソッドを呼び出して Equals 2 つの値が等しいかどうかを判断するか、 メソッドを呼び出して CompareTo 2 つの Double 値間の関係を判断すると、多くの場合、予期しない結果が発生します。 これは次の例で明らかです。2 つの明らかに等しい Double 値は 15 桁の精度を持ち、2 番目の値は 17 であるため、等しくないことがわかります。

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

open System

let value1 = 0.333333333333333
let value2 = 1. / 3.
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

Module Example
   Public Sub Main()
      Dim value1 As Double = .333333333333333
      Dim value2 As Double = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

さまざまなコード パスに従い、さまざまな方法で操作される計算値は、多くの場合、等しくないことが証明されます。 次の例では、1 つの Double 値が 2 乗され、平方根が計算されて元の値が復元されます。 2 つ目 Double は 3.51 で乗算され、結果の平方根が 3.51 で除算される前に 2 乗して元の値を復元します。 2 つの値は同じであるように見えますが、 メソッドの Equals(Double) 呼び出しは、それらが等しくないことを示します。 "R" 標準書式指定文字列を使用して、各 Double 値のすべての有効桁数を表示する結果文字列を返すと、2 番目の値が 1 番目より小さい .0000000000001であることが示されます。

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

open System

let value1 = 
    Math.Pow(100.10142, 2)
    |> sqrt

let value2 = 
    let v = pown (value1 * 3.51) 2
    (Math.Sqrt v) / 3.51

printfn $"{value1} = {value2}: {value1.Equals value2}\n"
printfn $"{value1:R} = {value2:R}"
// The example displays the following output:
//    100.10142 = 100.10142: False
//
//    100.10142 = 100.10141999999999

Module Example
   Public Sub Main()
      Dim value1 As Double = 100.10142
      value1 = Math.Sqrt(Math.Pow(value1, 2))
      Dim value2 As Double = Math.Pow(value1 * 3.51, 2)
      value2 = Math.Sqrt(value2) / 3.51
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:R} = {1:R}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'    100.10142 = 100.10142: False
'    
'    100.10142 = 100.10141999999999

精度の低下が比較の結果に影響を与える可能性がある場合は、 メソッドまたは CompareTo メソッドを呼び出す次のいずれかの代替手段をEquals採用できます。

• メソッドを 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
  

  open System
  
  let v1 = 0.333333333333333
  let v2 = 1. / 3.
  let precision = 7
  let value1 = Math.Round(v1, precision)
  let value2 = Math.Round(v2, precision)
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = .333333333333333
        Dim value2 As Double = 1/3
        Dim precision As Integer = 7
        value1 = Math.Round(value1, precision)
        value2 = Math.Round(value2, precision)
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  精度の問題は、引き続き中間値の丸めにも適用されます。 詳細については、Math.Round(Double, Int32, MidpointRounding) メソッドを参照してください。

• 等値ではなく近似等価性をテストします。 そのためには、2 つの値が異なるが等しい絶対値を定義するか、小さい値が大きい値から分岐できる相対量を定義する必要があります。

  警告

  Double.Epsilon は、等価性をテストするときに、2 つの Double 値間の距離の絶対メジャーとして使用される場合があります。 ただし、 Double.Epsilon は、値が 0 の に加算または減算 Double できる最小の値を測定します。 ほとんどの正と負 Double の値では、 の Double.Epsilon 値が小さすぎて検出できません。 したがって、0 の値を除き、等しいかどうかをテストで使用することはお勧めしません。

  次の例では、後者の方法を使用して、 IsApproximatelyEqual 2 つの値の相対差をテストするメソッドを定義します。 また、 メソッドと メソッドの呼び出し 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
  

  open System
  
  let isApproximatelyEqual (value1: double) (value2: double) (epsilon: double) =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      else
          // Handle NaN, Infinity.
          if Double.IsInfinity value1 || Double.IsNaN value1 then 
              value1.Equals value2
          elif Double.IsInfinity value2 || Double.IsNaN value2 then
              value1.Equals value2
          else
              // Handle zero to avoid division by zero
              let divisor = max value1 value2
              let divisor = 
                  if divisor.Equals 0 then
                      min value1 value2
                  else 
                      divisor
              abs ((value1 - value2) / divisor) <= epsilon
  
  let one1 = 0.1 * 10.
  let mutable one2 = 0.
  for _ = 1 to 10 do
      one2 <- one2 + 0.1
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000000001}"
  
  // The example displays the following output:
  //       1 = 0.99999999999999989: False
  //       1 is approximately equal to 0.99999999999999989: True
  

  Module Example
     Public Sub Main()
        Dim one1 As Double = .1 * 10
        Dim one2 As Double = 0
        For ctr As Integer = 1 To 10
           one2 += .1
        Next
        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))   
     End Sub
  
     Function IsApproximatelyEqual(value1 As Double, value2 As Double, 
                                   epsilon As Double) As Boolean
        ' If they are equal anyway, just return True.
        If value1.Equals(value2) Then Return True
        
        ' Handle NaN, Infinity.
        If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then
           Return value1.Equals(value2)
        Else If Double.IsInfinity(value2) Or Double.IsNaN(value2)
           Return value1.Equals(value2)
        End If
        
        ' Handle zero to avoid division by zero
        Dim divisor As Double = Math.Max(value1, value2)
        If divisor.Equals(0) Then
           divisor = Math.Min(value1, value2)
        End If 
        
        Return Math.Abs((value1 - value2) / divisor) <= epsilon           
     End Function
  End Module
  ' The example displays the following output:
  '       1 = 0.99999999999999989: False
  '       1 is approximately equal to 0.99999999999999989: True
  

Floating-Point の値と例外

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

• 浮動小数点演算の結果が変換先の形式に対して小さすぎる場合、結果は 0 になります。 これは、次の例に示すように、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
  

  let value1 = 1.1632875981534209e-225
  let value2 = 9.1642346778e-175
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals 0.0}"
  // The example displays the following output:
  //       1.16328759815342E-225 * 9.1642346778E-175 = 0
  //       0 = 0: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 1.1632875981534209e-225
        Dim value2 As Double = 9.1642346778e-175
        Dim result As Double = value1 * value2
        Console.WriteLine("{0} * {1} = {2}", value1, value2, result)
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0))
     End Sub
  End Module
  ' The example displays the following output:
  '       1.16328759815342E-225 * 9.1642346778E-175 = 0
  '       0 = 0: True
  

• 浮動小数点演算の結果の大きさが変換先の形式の範囲を超える場合、操作の結果は PositiveInfinity 、結果の符号に応じて または NegativeInfinityになります。 オーバーフローする操作の結果は でPositiveInfinity、オーバーフロー Double.MaxValueDouble.MinValueする操作の結果は NegativeInfinityです。次の例に示します。

  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
  

  open System
  
  let value1 = 4.565e153
  let value2 = 6.9375e172
  let result = value1 * value2
  printfn $"PositiveInfinity: {Double.IsPositiveInfinity result}"
  printfn $"NegativeInfinity: {Double.IsNegativeInfinity result}\n"
  
  let value3 = - value1
  let result2 = value2 * value3
  printfn $"PositiveInfinity: {Double.IsPositiveInfinity result2}"
  printfn $"NegativeInfinity: {Double.IsNegativeInfinity result2}"
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example
     Public Sub Main()
        Dim value1 As Double = 4.565e153
        Dim value2 As Double = 6.9375e172
        Dim result As Double = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Double.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Double.IsNegativeInfinity(result))
        Console.WriteLine()                  
        value1 = -value1
        result = value1 * value2
        Console.WriteLine("PositiveInfinity: {0}", 
                           Double.IsPositiveInfinity(result))
        Console.WriteLine("NegativeInfinity: {0}", 
                          Double.IsNegativeInfinity(result))
     End Sub
  End Module
  ' The example displays the following output:
  '       PositiveInfinity: True
  '       NegativeInfinity: False
  '       
  '       PositiveInfinity: False
  '       NegativeInfinity: True
  

  PositiveInfinity また、正の配当でゼロで除算し NegativeInfinity 、負の配当でゼロで除算した結果も得られます。

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

  • 0 で除算し、除数を 0 にします。 ゼロ除算の他のケースでは、 または NegativeInfinityがPositiveInfinity発生します。

• 入力が無効な浮動小数点演算。 たとえば、負の値を指定して メソッドを Math.Sqrt 呼び出すと、 が返 NaNされます。これは、負の値より大きい値を持つメソッドを呼び出 Math.Acos す場合と同様です。

• 値 Double.NaNが である引数を持つすべての操作。

型変換と Double 構造体

構造体では Double 、明示的または暗黙的な変換演算子は定義されません。代わりに、コンパイラによって変換が実装されます。

プリミティブ数値型から への Double 値の変換は拡大変換であるため、コンパイラが明示的に要求しない限り、明示的なキャスト演算子や変換メソッドの呼び出しは必要ありません。 たとえば、C# コンパイラでは から Decimal への Double変換にキャスト演算子が必要ですが、Visual Basic コンパイラでは必要ありません。 次の例では、他のプリミティブ数値型の最小値または最大値を に Double変換します。

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                           Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                           Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                           Single.MinValue, Single.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      double dblValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal))
            dblValue = (Double) value;
         else
            dblValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

open System

let values: obj[] = 
    [| Byte.MinValue; Byte.MaxValue; Decimal.MinValue
       Decimal.MaxValue; Int16.MinValue; Int16.MaxValue
       Int32.MinValue; Int32.MaxValue; Int64.MinValue
       Int64.MaxValue; SByte.MinValue; SByte.MaxValue
       Single.MinValue; Single.MaxValue; UInt16.MinValue
       UInt16.MaxValue; UInt32.MinValue, UInt32.MaxValue
       UInt64.MinValue; UInt64.MaxValue |]

for value in values do
    let dblValue = value :?> double
    printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({dblValue.GetType().Name})"
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                                 Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                                 Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                                 Single.MinValue, Single.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim dblValue As Double
      For Each value In values
         dblValue = value
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'    0 (Byte) --> 0 (Double)
'    255 (Byte) --> 255 (Double)
'    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
'    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
'    -32768 (Int16) --> -32768 (Double)
'    32767 (Int16) --> 32767 (Double)
'    -2147483648 (Int32) --> -2147483648 (Double)
'    2147483647 (Int32) --> 2147483647 (Double)
'    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
'    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
'    -128 (SByte) --> -128 (Double)
'    127 (SByte) --> 127 (Double)
'    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
'    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
'    0 (UInt16) --> 0 (Double)
'    65535 (UInt16) --> 65535 (Double)
'    0 (UInt32) --> 0 (Double)
'    4294967295 (UInt32) --> 4294967295 (Double)
'    0 (UInt64) --> 0 (Double)
'    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

さらに、Single値 Single.NaN、Single.PositiveInfinity、および Single.NegativeInfinity は、それぞれ 、Double.PositiveInfinity、および Double.NegativeInfinityに変換Double.NaNされます。

一部の数値型の値を値に Double 変換すると、精度が失われる可能性があることに注意してください。 例が示すように、および UInt64 の値を値DoubleにDecimalInt64変換すると、精度が失われる可能性があります。

他のプリミティブ数値データ型の Double 値への値への変換は縮小変換であり、キャスト演算子 (C#)、変換メソッド (Visual Basic の場合)、またはメソッドの呼び出しが Convert 必要です。 ターゲットのデータ型とプロパティによって定義されるターゲット データ型の範囲外の値は、次のMinValueMaxValue表に示すように動作します。

変換後の型	結果
任意の整数型	OverflowExceptionチェックされたコンテキストで変換が発生した場合の例外。 オフのコンテキスト (C# の既定値) で変換が発生した場合、変換操作は成功しますが、値はオーバーフローします。
Decimal	OverflowException 例外。
Single	Single.NegativeInfinity 負の値の場合は 。 Single.PositiveInfinity 正の値の場合は 。

さらに、、Double.NaNDouble.PositiveInfinity、 Double.NegativeInfinity は、チェックされたコンテキスト内の整数への変換に 対して をOverflowExceptionスローしますが、チェックされていないコンテキストで整数に変換すると、これらの値がオーバーフローします。 への Decimal変換では、常に がスローされます OverflowException。 へのSingle変換の場合、それぞれ 、Single.PositiveInfinity、および Single.NegativeInfinityにSingle.NaN変換されます。

精度が失われると、値が別の数値型に変換 Double される可能性があることに注意してください。 整数型のいずれかに変換する場合、例の出力に示すように、値が丸められた場合 (Visual Basic の場合と同様)、または切り捨てられた (C# のように) 小数部分が失われます Double 。 と Single の値へのDecimal変換の場合、値にDoubleターゲット データ型の正確な表現が含まれていない可能性があります。

次の例では、複数の値を他のいくつかの Double 数値型に変換します。 変換は、Visual Basic (既定値)、C# (チェックされたキーワード (keyword)のため)、F# (Checked モジュールのため) のチェックされたコンテキストで発生します。 この例の出力は、チェックが解除されたコンテキストの両方で変換の結果を示しています。 Visual Basic では、コンパイラ スイッチを使用してコンパイルし、C# で ステートメントを /removeintchecks+ コメントアウトし、F# で ステートメントをコメントアウト checked することで、オフのコンテキストで変換を open Checked 実行できます。

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
                          12345.6789, 67890.1234, Double.MaxValue,
                          Double.NaN, Double.PositiveInfinity,
                          Double.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }
            try {
                Single sValue = (float) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  sValue, sValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Single.", value);
            }
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

open System
open Checked

let values = 
    [| Double.MinValue; -67890.1234; -12345.6789
       12345.6789; 67890.1234; Double.MaxValue
       Double.NaN; Double.PositiveInfinity;
       Double.NegativeInfinity |]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."
    try
        let sValue = float32 value
        printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Single."
    printfn ""
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

Module Example
   Public Sub Main()
      Dim values() As Double = { Double.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Double.MaxValue,
                                 Double.NaN, Double.PositiveInfinity,
                                 Double.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Int64 = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try
         Try
             Dim sValue As Single = CSng(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               sValue, sValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Single.", value)
         End Try
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -1.79769313486232E+308 to Int64.
'       Unable to convert -1.79769313486232E+308 to UInt64.
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.1234 to UInt64.
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       Unable to convert 1.79769313486232E+308 to Int64.
'       Unable to convert 1.79769313486232E+308 to UInt64.
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)

数値型の変換の詳細については、「.NET Frameworkの型変換」および「型変換テーブル」を参照してください。

Floating-Point 機能

構造体と関連する型は Double 、次の領域で操作を実行するメソッドを提供します。

• 値の比較。 メソッドを Equals 呼び出して、2 つの Double 値が等しいかどうかを判断するか、 メソッドを CompareTo 呼び出して 2 つの値間の関係を判断できます。

  構造体では Double 、比較演算子の完全なセットもサポートされています。 たとえば、等しいか等しくないかをテストしたり、1 つの値が別の値以上であるかどうかを判断したりできます。 オペランドの 1 つが 以外 Doubleの数値型の場合、比較を実行する前に に Double 変換されます。

  警告

  精度の違いにより、等しいと予想される 2 つの Double 値が等しくない可能性があり、これは比較の結果に影響します。 2 つのDouble値の比較の詳細については、「等価性のテスト」セクションを参照してください。

  また、、IsInfinity、IsPositiveInfinity、および IsNegativeInfinity メソッドをIsNaN呼び出して、これらの特別な値をテストすることもできます。

• 数学演算。 加算、減算、乗算、除算などの一般的な算術演算は、メソッドではなく、言語コンパイラと共通中間言語 (CIL) 命令によって Double 実装されます。 算術演算のオペランドの 1 つが 以外 Doubleの数値型の場合、演算を実行する前に に Double 変換されます。 操作の結果も値になります Double 。

  その他の数学的操作は、 クラスで (Shared Visual Basic の場合) メソッドをSystem.Math呼び出staticすことによって実行できます。 これには、算術 (、Math.Sign、、 Math.SqrtなどMath.Abs)、geometry (や などMath.CosMath.Sin)、微積分 (などMath.Log) に一般的に使用される追加のメソッドが含まれています。

  値内の個々のビットを Double 操作することもできます。 メソッドは BitConverter.DoubleToInt64Bits 、 Double 値のビット パターンを 64 ビット整数で保持します。 メソッドは BitConverter.GetBytes(Double) 、バイト配列内のビット パターンを返します。

• 丸め。 丸めは、浮動小数点表現と精度の問題に起因する値間の差の影響を軽減するための手法としてよく使用されます。 メソッドを Double 呼び出すことで値を Math.Round 丸めることができます。

• 書式設定。 メソッドを Double 呼び出すか、複合書式指定機能を ToString 使用して、値を文字列形式に変換できます。 書式指定文字列が浮動小数点値の文字列表現を制御する方法については、「 標準の数値書式指定文字列 」および 「カスタム数値書式指定文字列 」トピックを参照してください。

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

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

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

  種類	最大精度	内部精度
  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
  

  let value = 0.1
  let result1 = value * 10.
  let mutable result2 = 0.
  for i = 1 to 10 do
      result2 <- result2 + value
  
  printfn $".1 * 10:           {result1:R}"
  printfn $".1 Added 10 times: {result2:R}"
  // The example displays the following output:
  //       .1 * 10:           1
  //       .1 Added 10 times: 0.99999999999999989
  

  Module Example
     Public Sub Main()
        Dim value As Double = .1
        Dim result1 As Double = value * 10
        Dim result2 As Double
        For ctr As Integer = 1 To 10
           result2 += value
        Next
        Console.WriteLine(".1 * 10:           {0:R}", result1)
        Console.WriteLine(".1 Added 10 times: {0:R}", result2)
     End Sub
  End Module
  ' The example displays the following output:
  '       .1 * 10:           1
  '       .1 Added 10 times: 0.99999999999999989
  

フィールド

E	定数 e で指定された自然対数底を表します。
Epsilon	ゼロより大きい最小の Double 値を表します。 このフィールドは定数です。
MaxValue	Double の最大有効値を表します。 このフィールドは定数です。
MinValue	Double の最小有効値を表します。 このフィールドは定数です。
NaN	非数 (NaN) の値を表します。 このフィールドは定数です。
NegativeInfinity	負の無限大を表します。 このフィールドは定数です。
NegativeZero	負の 0 (-0) の数値を表します。
Pi	定数 (π) を指定して、円の直径に対する円周の割合を表します。
PositiveInfinity	正の無限大を表します。 このフィールドは定数です。
Tau	定数 τ によって指定される、1 回のターンのラジアン数を表します。

メソッド

Abs(Double)	値の絶対を計算します。
Acos(Double)	値のアークコサインを計算します。
Acosh(Double)	値の双曲線アークコサインを計算します。
AcosPi(Double)	値のアークコサインを計算し、結果を で pi除算します。
Asin(Double)	値のアークサインを計算します。
Asinh(Double)	値の双曲線アークサインを計算します。
AsinPi(Double)	値のアークサインを計算し、結果を で pi除算します。
Atan(Double)	値のアークタンジェントを計算します。
Atan2(Double, Double)	2 つの値の商のアークタンジェントを計算します。
Atan2Pi(Double, Double)	2 つの値の商のアークタンジェントを計算し、結果を で pi除算します。
Atanh(Double)	値の双曲線アークタンジェントを計算します。
AtanPi(Double)	値のアークタンジェントを計算し、結果を pi で除算します。
BitDecrement(Double)	指定された値より小さい値を比較する最小の値に値をデクリメントします。
BitIncrement(Double)	指定した値より大きい値を比較する最小値に値をインクリメントします。
Cbrt(Double)	値のキューブ ルートを計算します。
Ceiling(Double)	値の上限を計算します。
Clamp(Double, Double, Double)	値を包括的な最小値と最大値にクランプします。
CompareTo(Double)	このインスタンスと指定した倍精度浮動小数点数を比較し、このインスタンスの値が指定した倍精度浮動小数点数の値よりも小さいか、同じか、または大きいかを示す整数を返します。
CompareTo(Object)	このインスタンスと指定したオブジェクトを比較し、このインスタンスの値が指定したオブジェクトの値よりも小さいか、同じか、または大きいかを示す整数を返します。
CopySign(Double, Double)	値の符号を別の値の符号にコピーします。
Cos(Double)	値のコサインを計算します。
Cosh(Double)	値の双曲線余弦を計算します。
CosPi(Double)	によって pi多重化された値のコサインを計算します。
CreateChecked<TOther>(TOther)	現在の型のインスタンスを値から作成し、現在の型の表現可能な範囲外の値に対してオーバーフロー例外をスローします。
CreateSaturating<TOther>(TOther)	現在の型のインスタンスを値から作成し、現在の型の表現可能な範囲外の値を飽和させます。
CreateTruncating<TOther>(TOther)	現在の型のインスタンスを値から作成し、現在の型の表現可能な範囲外の値を切り捨てます。
DegreesToRadians(Double)	指定した値を度からラジアンに変換します。
Equals(Double)	このインスタンスと指定した Double オブジェクトが同じ値を表しているかどうかを示す値を返します。
Equals(Object)	このインスタンスが指定されたオブジェクトに等しいかどうかを示す値を返します。
Exp(Double)	特定の E 電力に対して発生するコンピューティング。
Exp10(Double)	特定の 10 電力に対して発生するコンピューティング。
Exp10M1(Double)	特定の 10 累乗に対して発生した計算を行い、1 を減算します。
Exp2(Double)	特定の 2 電力に対して発生するコンピューティング。
Exp2M1(Double)	特定の 2 累乗に対して発生した計算を行い、1 を減算します。
ExpM1(Double)	特定の E 累乗に対して発生した計算を行い、1 を減算します。
Floor(Double)	値のフロアを計算します。
FusedMultiplyAdd(Double, Double, Double)	3 つの値の乗算加算を計算します。
GetHashCode()	このインスタンスのハッシュ コードを返します。
GetTypeCode()	Double 値型の TypeCode を返します。
Hypot(Double, Double)	直角三角形の短辺の長さを表す 2 つの値を指定して、偽表を計算します。
Ieee754Remainder(Double, Double)	IEEE 754 で指定された 2 つの値の残りの部分を計算します。
ILogB(Double)	値の整数対数を計算します。
IsEvenInteger(Double)	値が偶数の整数を表すかどうかを判断します。
IsFinite(Double)	指定の値が有限 (ゼロ、非正規、または正規) かどうかを判断します。
IsInfinity(Double)	指定した数値が負または正の無限大と評価されるかどうかを示す値を返します。
IsInteger(Double)	値が整数値を表すかどうかを判断します。
IsNaN(Double)	指定した値が非数値 (NaN) かどうかを示す値を返します。
IsNegative(Double)	指定した値が負かどうかを判断します。
IsNegativeInfinity(Double)	指定した数値が負の無限大と評価されるかどうかを示す値を返します。
IsNormal(Double)	指定した値が正規かどうかを判断します。
IsOddInteger(Double)	値が奇数の整数を表すかどうかを判断します。
IsPositive(Double)	値が正かどうかを判断します。
IsPositiveInfinity(Double)	指定した数値が正の無限大と評価されるかどうかを示す値を返します。
IsPow2(Double)	値が 2 の累乗であるかどうかを判断します。
IsRealNumber(Double)	値が実数を表すかどうかを判断します。
IsSubnormal(Double)	指定した値が非正規かどうかを判断します。
Lerp(Double, Double, Double)	指定された重み付けに基づいて、2 つの値間の線形補間を実行します。
Log(Double)	自然 (base-E 値の対数) を計算します。
Log(Double, Double)	指定した底の値の対数を計算します。
Log10(Double)	値の底 10 の対数を計算します。
Log10P1(Double)	値に 1 を加えた底 10 の対数を計算します。
Log2(Double)	値の log2 を計算します。
Log2P1(Double)	値に 1 を加えた底 2 の対数を計算します。
LogP1(Double)	値に 1 を加えた自然対数 (base-E) を計算します。
Max(Double, Double)	2 つの値を、より大きいコンピューティングと比較します。
MaxMagnitude(Double, Double)	2 つの値を、より大きいコンピューティングと比較します。
MaxMagnitudeNumber(Double, Double)	2 つの値を比較して、大きさが大きい計算を行い、入力が の場合は NaNもう一方の値を返します。
MaxNumber(Double, Double)	2 つの値を比較して、より大きいを計算し、入力が の場合は NaNもう一方の値を返します。
Min(Double, Double)	2 つの値を比較して計算します。この値は小さくなります。
MinMagnitude(Double, Double)	2 つの値を比較して計算します。この値は小さくなります。
MinMagnitudeNumber(Double, Double)	2 つの値を比較して、大きさが小さい計算を行い、入力が の場合は NaNもう一方の値を返します。
MinNumber(Double, Double)	2 つの値を比較して、より小さい計算を行い、入力が の場合は NaNもう一方の値を返します。
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 文字のスパンを値に解析します。
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 文字のスパンを値に解析します。
Parse(ReadOnlySpan<Char>, IFormatProvider)	文字のスパンを値に解析します。
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	指定したスタイルおよびカルチャ固有の書式による数値の文字列表現を含む文字スパンを、等価の倍精度浮動小数点数に変換します。
Parse(String)	数値の文字列形式を、等価の倍精度浮動小数点数に変換します。
Parse(String, IFormatProvider)	指定したカルチャに固有の書式による数値の文字列形式を、それと等価な倍精度浮動小数点数に変換します。
Parse(String, NumberStyles)	数値の指定したスタイルでの文字列形式を、それと等価な倍精度浮動小数点数に変換します。
Parse(String, NumberStyles, IFormatProvider)	指定したスタイルおよびカルチャ固有の書式での数値の文字列形式を、等価の倍精度浮動小数点数に変換します。
Pow(Double, Double)	特定の累乗に対して発生した値を計算します。
RadiansToDegrees(Double)	指定した値をラジアンから度に変換します。
ReciprocalEstimate(Double)	値の逆数の推定値を計算します。
ReciprocalSqrtEstimate(Double)	値の逆平方根の推定値を計算します。
RootN(Double, Int32)	値の n 番目のルートを計算します。
Round(Double)	既定の丸めモード (ToEven) を使用して、値を最も近い整数に丸めます。
Round(Double, Int32)	既定の丸めモード (ToEven) を使用して、指定した桁数の小数部に値を丸めます。
Round(Double, Int32, MidpointRounding)	既定の丸めモード (ToEven) を使用して、指定した桁数の小数部に値を丸めます。
Round(Double, MidpointRounding)	指定した丸めモードを使用して、値を最も近い整数に丸めます。
ScaleB(Double, Int32)	指定した累乗に引き上げられた値とその基数の積を計算します。
Sign(Double)	値の符号を計算します。
Sin(Double)	値のサインを計算します。
SinCos(Double)	値のサインとコサインを計算します。
SinCosPi(Double)	値のサインとコサインを計算します。
Sinh(Double)	値の双曲線正弦を計算します。
SinPi(Double)	に乗算 piされた値のサインを計算します。
Sqrt(Double)	値の平方根を計算します。
Tan(Double)	値のタンジェントを計算します。
Tanh(Double)	値の双曲線正接を計算します。
TanPi(Double)	によって多重化された値のタンジェントを pi計算します。
ToString()	このインスタンスの数値を、それと等価な文字列形式に変換します。
ToString(IFormatProvider)	このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。
ToString(String)	指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。
ToString(String, IFormatProvider)	このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。
Truncate(Double)	値を切り捨てます。
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	現在のインスタンスの値を UTF-8 として指定されたバイトスパンに書式設定しようとします。
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	現在の double 型インスタンスの値の、指定した文字スパンへの書式設定を試みます。
TryParse(ReadOnlySpan<Byte>, Double)	数値の文字列表現を含む UTF-8 文字スパンを、等価の倍精度浮動小数点数に変換しようとします。
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	UTF-8 文字のスパンを値に解析しようとします。
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	UTF-8 文字のスパンを値に解析しようとします。
TryParse(ReadOnlySpan<Char>, Double)	指定したスタイルおよびカルチャ固有の書式による数値のスパン表現を、等価の倍精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	文字のスパンを値に解析しようとします。
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	指定したスタイルおよびカルチャ固有の書式による数値の文字列表現を含む文字スパンを、等価の倍精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。
TryParse(String, Double)	数値の文字列形式を、等価の倍精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。
TryParse(String, IFormatProvider, Double)	文字列を値に解析しようとします。
TryParse(String, NumberStyles, IFormatProvider, Double)	指定したスタイルおよびカルチャ固有の書式での数値の文字列形式を、等価の倍精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。

演算子

Equality(Double, Double)	指定した 2 つの Double 値が等しいかどうかを示す値を返します。
GreaterThan(Double, Double)	指定した Double 値が、指定したもう 1 つの Double 値より大きいかどうかを示す値を返します。
GreaterThanOrEqual(Double, Double)	指定した Double 値が、指定したもう 1 つの Double 値以上かどうかを示す値を返します。
Inequality(Double, Double)	指定した 2 つの Double 値が等しくないかどうかを示す値を返します。
LessThan(Double, Double)	指定した Double 値が、指定したもう 1 つの Double 値より小さいかどうかを示す値を返します。
LessThanOrEqual(Double, Double)	指定した Double 値が、指定したもう 1 つの Double 値以下かどうかを示す値を返します。

明示的なインターフェイスの実装

IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	合計を計算するために 2 つの値を加算します。
IAdditiveIdentity<Double,Double>.AdditiveIdentity	現在の型の加算 ID を取得します。
IBinaryNumber<Double>.AllBitsSet	すべてのビットが設定されているバイナリ型のインスタンスを取得します。
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	2 つの値のビットごとの と を計算します。
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	2 つの値のビットごとの または を計算します。
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	2 つの値の排他的またはを計算します。
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	指定された値の 1-補数表現を計算します。
IConvertible.ToBoolean(IFormatProvider)	このメンバーの詳細については、「ToBoolean(IFormatProvider)」をご覧ください。
IConvertible.ToByte(IFormatProvider)	このメンバーの詳細については、「ToByte(IFormatProvider)」をご覧ください。
IConvertible.ToChar(IFormatProvider)	この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。
IConvertible.ToDateTime(IFormatProvider)	この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。
IConvertible.ToDecimal(IFormatProvider)	このメンバーの詳細については、「ToDecimal(IFormatProvider)」をご覧ください。
IConvertible.ToDouble(IFormatProvider)	このメンバーの詳細については、「ToDouble(IFormatProvider)」をご覧ください。
IConvertible.ToInt16(IFormatProvider)	このメンバーの詳細については、「ToInt16(IFormatProvider)」をご覧ください。
IConvertible.ToInt32(IFormatProvider)	このメンバーの詳細については、「ToInt32(IFormatProvider)」をご覧ください。
IConvertible.ToInt64(IFormatProvider)	このメンバーの詳細については、「ToInt64(IFormatProvider)」をご覧ください。
IConvertible.ToSByte(IFormatProvider)	このメンバーの詳細については、「ToSByte(IFormatProvider)」をご覧ください。
IConvertible.ToSingle(IFormatProvider)	このメンバーの詳細については、「ToSingle(IFormatProvider)」をご覧ください。
IConvertible.ToType(Type, IFormatProvider)	このメンバーの詳細については、「ToType(Type, IFormatProvider)」をご覧ください。
IConvertible.ToUInt16(IFormatProvider)	このメンバーの詳細については、「ToUInt16(IFormatProvider)」をご覧ください。
IConvertible.ToUInt32(IFormatProvider)	このメンバーの詳細については、「ToUInt32(IFormatProvider)」をご覧ください。
IConvertible.ToUInt64(IFormatProvider)	このメンバーの詳細については、「ToUInt64(IFormatProvider)」をご覧ください。
IDecrementOperators<Double>.Decrement(Double)	値をデクリメントします。
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	1 つの値を別の値で除算して商を計算します。
IFloatingPoint<Double>.GetExponentByteCount()	の一部として書き込まれるバイト数を TryWriteExponentLittleEndian(Span<Byte>, Int32)取得します。
IFloatingPoint<Double>.GetExponentShortestBitLength()	現在の指数の最短 2 の補数表現の長さをビット単位で取得します。
IFloatingPoint<Double>.GetSignificandBitLength()	現在の仮数の長さをビット単位で取得します。
IFloatingPoint<Double>.GetSignificandByteCount()	の一部として書き込まれるバイト数を TryWriteSignificandLittleEndian(Span<Byte>, Int32)取得します。
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	現在の指数をビッグ エンディアン形式で特定のスパンに書き込もうとします。
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	現在の指数をリトル エンディアン形式で特定のスパンに書き込もうとします。
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	現在の仮数をビッグ エンディアン形式で特定のスパンに書き込もうとします。
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	特定のスパンに現在の仮数をリトル エンディアン形式で書き込もうとします。
IFloatingPointConstants<Double>.E	数学定数 eを取得します。
IFloatingPointConstants<Double>.Pi	数学定数 piを取得します。
IFloatingPointConstants<Double>.Tau	数学定数 tauを取得します。
IFloatingPointIeee754<Double>.Epsilon	を生成しない に追加 0 できる最小の値を 0取得します。
IFloatingPointIeee754<Double>.NaN	を表す値を取得します NaN。
IFloatingPointIeee754<Double>.NegativeInfinity	負 infinityの を表す値を取得します。
IFloatingPointIeee754<Double>.NegativeZero	負 zeroの を表す値を取得します。
IFloatingPointIeee754<Double>.PositiveInfinity	正 infinityの を表す値を取得します。
IIncrementOperators<Double>.Increment(Double)	値をインクリメントします。
IMinMaxValue<Double>.MaxValue	現在の型の最大値を取得します。
IMinMaxValue<Double>.MinValue	現在の型の最小値を取得します。
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	2 つの値を除算して、剰余または剰余を計算します。
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	現在の型の乗法 ID を取得します。
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	2 つの値を乗算して製品を計算します。
INumberBase<Double>.IsCanonical(Double)	値が正規表現内にあるかどうかを判断します。
INumberBase<Double>.IsComplexNumber(Double)	値が複素数を表すかどうかを判断します。
INumberBase<Double>.IsImaginaryNumber(Double)	値が純粋な虚数を表すかどうかを判断します。
INumberBase<Double>.IsZero(Double)	値が 0 かどうかを判断します。
INumberBase<Double>.One	型の値 1 を取得します。
INumberBase<Double>.Radix	型の基数 (基本) を取得します。
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	倍精度浮動小数点数を表します。
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	倍精度浮動小数点数を表します。
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	倍精度浮動小数点数を表します。
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	現在の型のインスタンスを別の型に変換しようとします。現在の型の表現可能な範囲外の値に対してオーバーフロー例外がスローされます。
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	現在の型のインスタンスを別の型に変換し、現在の型の表現可能な範囲外の値を飽和させます。
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	現在の型のインスタンスを別の型に変換し、現在の型の表現可能な範囲外の値を切り捨てようとします。
INumberBase<Double>.Zero	型の値 0 を取得します。
ISignedNumber<Double>.NegativeOne	型の値 -1 を取得します。
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	2 つの値を減算して差を計算します。
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	値の単項否定を計算します。
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	値の単項プラスを計算します。

スレッド セーフ

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

こちらもご覧ください

• Decimal
• Single
• サンプル: .NET Core WinForms 書式設定ユーティリティ (C#)
• サンプル: .NET Core WinForms 書式設定ユーティリティ (Visual Basic)