Double Структура

Определение

Пространство имен:

System

Сборки:

netstandard.dll, System.Runtime.dll

Исходный код:

Double.cs

Представляет число с плавающей запятой двойной точности.

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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 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 IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanFormattable ISpanParsable<Double> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<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>

Примеры

В следующем примере кода показано использование 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;
        }
    }
}

// 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().EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd().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 Тип значения представляет 64-разрядное число двойной точности со значениями от отрицательного 1,79769313486232e308 до положительного 1,79769313486232e308, а также положительного или отрицательного нуля, PositiveInfinityNegativeInfinityа не числа (NaN). Он предназначен для представления значений, которые чрезвычайно большие (например, расстояния между планетами или галактиками) или крайне малы (например, молекулярной массы вещества в килограммах) и которые часто являются неуловкими (например, расстояние от земли к другой солнечной системе). Тип Double соответствует стандарту IEC 60559:1989 (IEEE 754) для арифметики с плавающей запятой.

Представление и точность чисел с плавающей точкой

Тип Double данных хранит значения с плавающей запятой двойной точности в 64-разрядном двоичном формате, как показано в следующей таблице:

Часть	Биты
Значение или мантисса	0-51
Exponent	52-62
Знак (0 = положительный, 1 = отрицательный)	63

Так же, как десятичные дроби не могут точно представлять некоторые дробные значения (например, 1/3 или Math.PI), двоичные дроби не могут представлять некоторые дробные значения. Например, 1/10, которая представлена именно как десятичная дробь .1, представлена как двоичная дробь .001100110011, с последовательностью "0011", повторяющейся до бесконечности. В этом случае значение с плавающей запятой дает неточное представление о числе, которое оно обозначает. Выполнение дополнительных математических операций с исходным значением с плавающей запятой часто приводит к увеличению его нехватки точности. Например, если вы сравниваете результат умножения .1 на 10 и добавляете .1 к .1 девять раз, вы увидите, что это добавление, так как оно включало восемь больше операций, привело к снижению точности. (До версии .NET 10 эта разница заметна только в том случае, если вы отображаете оба значения , используя строку стандартного числового формата "R" , которая отображает все до 17 цифр точности, поддерживаемой типом .)

using System;

public class Example13
{
    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:           {result1:R}");
        Console.WriteLine($".1 Added 10 times: {result2:R}");
    }
}
// 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 Example14
    Public Sub Run()
        Dim value As Double = 0.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 цифр сохраняется внутри системы. Это означает, что некоторые операции с плавающей запятой могут не обладать достаточной точностью для изменения значения с плавающей запятой. Это показывается в следующем примере. Он задает очень большое число с плавающей запятой, а затем прибавляет к нему произведение Double.Epsilon и одного квадриллиона. Однако результат слишком мал, чтобы изменить первоначальное значение с плавающей запятой. Его наименьшая значимая цифра составляет тысячы, в то время как наиболее значимая цифра в продукте составляет ^10-309.

using System;

public class Example14
{
    public static void Main()
    {
        Double value = 123456789012.34567;
        Double additional = Double.Epsilon * 1e15;
        Console.WriteLine($"{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 Example15
    Public Sub Run()
        Dim value As Double = 123456789012.34567
        Dim additional As Double = Double.Epsilon * 1.0E+15
        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

Ограниченная точность числа с плавающей запятой имеет несколько последствий:

• Два числа с плавающей запятой, которые, как представляется, равны для определенной точности, могут не сравниться, так как их наименьшие значимые цифры отличаются. В следующем примере ряд чисел добавляется вместе, и их общее значение сравнивается с ожидаемым итогом.

  using System;
  
  public class Example10
  {
      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 ({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).
  

  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 Example11
      Public Sub Run()
          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).
  

  Два значения неравны из-за потери точности во время операций сложения. В этом случае проблему можно устранить, вызвав метод Math.Round(Double, Int32) для округления значений Double до требуемой точности перед выполнением сравнения.

• Математические операции или операции сравнения, использующие число с плавающей запятой, могут не дать тот же результат, если используется десятичное число, так как двоичное число с плавающей запятой может не совпадать с десятичным числом. Предыдущий пример иллюстрировал это, отображая результат умножения .1 на 10 и добавив .1 раз.

  Если точность в числовых операциях с дробными значениями важна, можно использовать Decimal тип, а не Double тип. Если точность в числовых операциях с целыми значениями, превышающими диапазон Int128 и UInt128 типов, важна, используйте BigInteger тип.

• Single значения имеют меньше точности, чем Double значения. Single Значение, преобразованное в казалось бы эквивалентноеDouble, часто не равно Double значению из-за различий в точности. В следующем примере результат идентичных операций деления назначается значению Double и значению Single . После того, как значение Single было приведено к Double, сравнение двух значений показывает, что они не равны.

  using System;
  
  public class Example9
  {
      public static void Run()
      {
          double value1 = 1 / 3.0;
          float sValue2 = 1 / 3.0f;
          double value2 = (double)sValue2;
          Console.WriteLine($"{value1:R} = {value2:R}: {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 Example10
      Public Sub Run()
          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 может отличаться в 32-разрядных и 64-разрядных версиях .NET. В следующем примере показано это различие, если литеральное значение -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);

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

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.4233060424477198E-305

Dim fromLiteral As Double = -4.4233060424477198E-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)

' 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

Проверка на равенство

Чтобы считаться равным, два значения Double должны представлять идентичные значения. Однако из-за различий в точности между значениями или из-за потери точности по одному или обоим значениям значения с плавающей запятой, которые, как ожидается, будут идентичными, часто оказываются неравными из-за различий в их наименее значимых цифрах. В результате вызовы метода Equals, чтобы определить, равны ли два значения, или вызовы метода CompareTo для определения связи между двумя значениями Double, часто дают непредвиденные результаты. Это очевидно в следующем примере, где два по-видимому равных Double значения оказываются неравными, так как первая имеет 15 цифр точности, а вторая имеет 17.

using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine($"{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 Example1
    Public Sub Run()
        Dim value1 As Double = 0.333333333333333
        Dim value2 As Double = 1 / 3
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module

' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

В случаях, когда потеря точности, скорее всего, влияет на результат сравнения, можно применить любой из следующих вариантов вызова Equals или CompareTo метода:

• Вызовите метод Math.Round, чтобы убедиться, что оба значения имеют одинаковую точность. Следующий пример изменяет предыдущий пример для использования этого подхода таким образом, чтобы два дробных значения были эквивалентны.

  double value1 = .333333333333333;
  double value2 = 1.0 / 3;
  int precision = 7;
  value1 = Math.Round(value1, precision);
  value2 = Math.Round(value2, precision);
  Console.WriteLine($"{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 Example3
      Public Sub Run()
          Dim value1 As Double = 0.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} = {1}: {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).

• Проверьте приблизительное равенство вместо точного равенства. Для этого необходимо определить либо абсолютную сумму, по которой эти два значения могут отличаться, но по-прежнему равны, либо определить относительную сумму, по которой меньшее значение может отойдет от большего значения.

  Предупреждение

  Double.Epsilon иногда используется в качестве абсолютной меры расстояния между двумя Double значениями при тестировании на равенство. Однако Double.Epsilon измеряет наименьшее возможное значение, которое можно добавить или вычесть из Double, значение которого равно нулю. Для большинства положительных и отрицательных значений Double значение Double.Epsilon слишком мало для обнаружения. Поэтому, за исключением значений, равных нулю, мы не рекомендуем использовать его в тестах на равенство.

  В следующем примере используется последний подход для определения метода IsApproximatelyEqual, который проверяет относительную разницу между двумя значениями. Метод делит на Math.Max(value1, value2), так чтобы сравнение было относительно наибольшего из двух значений (по модулю), что определяет результат в правильный порядок величины. Если Math.Max возвращается ноль (что происходит, когда одно значение равно нулю, а другое отрицательно), метод возвращается к Math.Min(value1, value2) использованию ненулевого значения в качестве разделителя. Он также сравнивает результаты вызовов метода IsApproximatelyEqual и метода Equals(Double).

  using System;
  
  public class Example3
  {
      public static void Main()
      {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
              one2 += .1;
  
          Console.WriteLine($"{one1} = {one2}: {one1.Equals(one2)}");
          Console.WriteLine($"{one1} is approximately equal to {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 Example4
      Public Sub Run()
          Dim one1 As Double = 0.1 * 10
          Dim one2 As Double = 0
          For ctr As Integer = 1 To 10
              one2 += 0.1
          Next
          Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0} is approximately equal to {1}: {2}",
                          one1, one2,
                          IsApproximatelyEqual(one1, one2, 0.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)
          ElseIf Double.IsInfinity(value2) Or Double.IsNaN(value2) Then
              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
  

Исключения и значения с плавающей запятой

В отличие от операций с целочисленными типами, которые вызывают DivideByZeroException деление на ноль или OverflowException переполнение в проверяемом контексте, операции с значениями с плавающей запятой не вызывают исключений. Вместо этого в исключительных случаях результат операции с плавающей запятой равен нулю, положительной бесконечности, отрицательной бесконечности или не является числом (NaN).

• Если результат операции с плавающей запятой слишком мал для целевого формата, результат равен нулю. Это может произойти при умножении двух очень маленьких чисел, как показано в следующем примере.

  using System;
  
  public class Example6
  {
      public static void Main()
      {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine($"{value1} * {value2} = {result}");
          Console.WriteLine($"{result} = 0: {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 Example7
      Public Sub Run()
          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, как это подходит для знака результата. Результат операции, которая переполняет Double.MaxValue, это PositiveInfinity, а результат операции, которая переполняет Double.MinValue, это NegativeInfinity, как показано в следующем примере.

  using System;
  
  public class Example7
  {
      public static void Main()
      {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}");
          Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}{Environment.NewLine}");
  
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}");
          Console.WriteLine($"NegativeInfinity: {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 Example8
      Public Sub Run()
          Dim value1 As Double = 4.565E+153
          Dim value2 As Double = 6.9375E+172
          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 - результат от следующих операций:

  • Деление на ноль с дивидендами от нуля. Обратите внимание, что другие случаи деления на ноль приводят либо к PositiveInfinity, либо к NegativeInfinity.

  • Любая операция с плавающей запятой с неверными данными. Например, вызов Math.Sqrt метода с отрицательным значением возвращается NaN, как и вызов Math.Acos метода со значением, превышающим одно или меньше отрицательного значения.

  • Любая операция с аргументом, значение которого равно Double.NaN.

Преобразование типов

Структура Double не определяет никаких явных или неявных операторов преобразования; Вместо этого преобразования реализуются компилятором.

Преобразование значения любого примитивного числового типа в Double является расширяющим преобразованием и поэтому не требует явного оператора приведения или вызова метода преобразования, если только компилятор явно не требует этого. Например, для компилятора C# требуется оператор приведения для преобразования из Decimal в Double, тогда как компилятору Visual Basic это не требуется. Следующий пример преобразует минимальное или максимальное значение других примитивных числовых типов в значение Double.

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 (dynamic value in values)
{
    if (value.GetType() == typeof(decimal))
        dblValue = (double)value;
    else
        dblValue = value;
    Console.WriteLine($"{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)

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 Example5
    Public Sub Run()
        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)

Кроме того, значения SingleSingle.NaN, Single.PositiveInfinityи Single.NegativeInfinity преобразуются в Double.NaN, Double.PositiveInfinityи Double.NegativeInfinityсоответственно.

Обратите внимание, что преобразование значения некоторых числовых типов в Double значение может привести к потере точности. Как показано в примере, при преобразовании DecimalInt64значений и UInt64 значений в Double значения возможна потеря точности.

Преобразование значения Double в значение любого другого примитивного числового типа данных является сужающим преобразованием и требует оператора приведения (в C#), метода преобразования (в Visual Basic) или вызова метода Convert. Значения, которые находятся за пределами диапазона целевого типа данных, определяемого MinValue и MaxValue свойств целевого типа, ведут себя, как показано в следующей таблице.

Тип целевого объекта	Result
Любой целочисленный тип	Исключение OverflowException, если преобразование происходит в проверенном контексте. Если преобразование происходит в неконтролируемом контексте (по умолчанию в C#), преобразование выполняется успешно, но значение переполняется.
Decimal	Исключение OverflowException .
Single	Single.NegativeInfinity для отрицательных значений. Single.PositiveInfinity для положительных значений.

Кроме того, Double.NaN, Double.PositiveInfinityи Double.NegativeInfinity выбрасывают OverflowException для преобразования в целые числа в контексте с проверкой, но эти значения переполняются при преобразовании в целые числа в контексте без проверки. Для преобразования в Decimal они всегда выбрасывают OverflowException. Для преобразований в Singleони преобразуются в Single.NaN, Single.PositiveInfinityи Single.NegativeInfinityсоответственно.

Потеря точности может привести к преобразованию Double значения в другой числовой тип. В случае преобразования в любой из целочисленных типов, как показано в примере, дробный компонент теряется, когда значение Double округляется (как в Visual Basic) или усечено (как в C#). Для преобразований в значения Decimal и Single значение Double может не иметь точного представления в целевом типе данных.

В следующем примере число значений Double преобразуется в несколько других числовых типов. Преобразования происходят в проверенном контексте в Visual Basic (по умолчанию), в C# (из-за ключевого слова checked) и в F# (из-за модуля Checked). Выходные данные из примера показывают результат преобразования как в проверенном, так и в непроверенном контексте. Вы можете выполнять преобразования в незаверяемом контексте в Visual Basic, скомпилировав с переключателем компилятора /removeintchecks+, в C# — закомментировав инструкцию checked, и в F# — закомментировав инструкцию open Checked.

using System;

public class Example5
{
    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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Int64.");
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to UInt64.");
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Decimal.");
                }
                try
                {
                    Single sValue = (float)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Single.");
                }
                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 Example6
    Public Sub Run()
        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)

Дополнительные сведения о преобразовании числовых типов см. в статье Type Conversion in .NET and Type Conversion Tables.

Функциональность для чисел с плавающей запятой

Структура Double и связанные типы предоставляют методы для выполнения операций в следующих областях:

• сравнение значений. Можно вызвать метод Equals, чтобы определить, равны ли два значения Double или метод CompareTo для определения связи между двумя значениями.

  Структура Double также поддерживает полный набор операторов сравнения. Например, можно проверить равенство или неравенство или определить, больше ли одно значение или равно другому. Если один из операндов является числовым типом, отличным от Double, он преобразуется в Double перед выполнением сравнения.

  Предупреждение

  Из-за различий в точности два Double значения, которые вы ожидаете, будут равными, могут оказаться неравными, что влияет на результат сравнения. Сведения о сравнении двух Double значений см. в разделе "Тест для равенства ".

  Можно также вызвать методы IsNaN, IsInfinity, IsPositiveInfinityи IsNegativeInfinity для проверки этих специальных значений.

• Математическая операция. Распространенные арифметические операции, такие как добавление, вычитание, умножение и деление, реализуются компиляторами языка и инструкциями CIL, а не методами Double . Если один из операндов в математической операции является числовым типом, отличным от типа Double, он преобразуется в операнду Double перед выполнением операции. Результат операции также является значением Double .

  Другие математические операции можно выполнять путем вызова методов static (Shared в Visual Basic) в классе System.Math. Он включает в себя дополнительные методы, часто используемые для арифметики (напримерMath.Abs, , Math.Signи ), геометрии (напримерMath.Sqrt, иMath.CosMath.Sin) и вычислений (напримерMath.Log, ).

  Вы также можете управлять отдельными битами в значении Double. Метод BitConverter.DoubleToInt64Bits сохраняет Double битовый шаблон значения в 64-разрядном целочисленном значении. Метод BitConverter.GetBytes(Double) возвращает свой битовый шаблон в массиве байтов.

• округление. Округление часто используется в качестве метода для снижения влияния различий между значениями, вызванных проблемами представления чисел с плавающей запятой и их точности. Можно округить значение Double путем вызова метода Math.Round.

• форматирование. Значение Double можно преобразовать в строковое представление, вызвав метод ToString или используя функцию составного форматирования. Для получения информации о том, как строковые форматы управляют строковым представлением значений с плавающей точкой, см. Стандартные числовые форматы и Пользовательские числовые форматы.

• Строки синтаксического анализа. Строковое представление значения с плавающей запятой можно преобразовать в значение Double, вызвав метод Parse или TryParse. Если операция синтаксического анализа завершается ошибкой, метод Parse создает исключение, а метод TryParse возвращает false.

• Преобразование типов. Структура Double предоставляет явную реализацию интерфейса для интерфейса IConvertible, который поддерживает преобразование между двумя стандартными типами данных .NET. Компиляторы языка также поддерживают неявное преобразование значений всех других стандартных числовых типов в Double значения. Преобразование значения любого стандартного числового типа в Double является расширяющим преобразованием и не требует использования оператора приведения или метода преобразования.

  Однако преобразование Int64 и Single значения могут привести к потере точности. В следующей таблице перечислены различия в точности для каждого из этих типов:

  Type	Максимальная точность	Внутренняя точность
  Double	15	17
  Int64	19 десятичных цифр	19 десятичных цифр
  Single	7 десятичных цифр	9 десятичных цифр

  Проблема точности чаще всего влияет на значения Single, которые преобразуются в значения Double. В следующем примере два значения, созданные идентичными операциями деления, неравны, так как одно из значений — это значение с плавающей запятой с одной точностью, преобразованное в значение Double.

  using System;
  
  public class Example13
  {
      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:           {result1:R}");
          Console.WriteLine($".1 Added 10 times: {result2:R}");
      }
  }
  // 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 Example14
      Public Sub Run()
          Dim value As Double = 0.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).
Pi	Представляет отношение окружности круга к его диаметру, заданному константой, π.
PositiveInfinity	Представляет положительную бесконечность. Это поле является константой.
Tau	Представляет количество радианов в одном повороте, указанное константой, fx.

Методы

Имя	Описание
Abs(Double)	Вычисляет абсолютное значение.
Acos(Double)	Вычисляет arc-cosine значения.
Acosh(Double)	Вычисляет гиперболический арк-косинус значения.
AcosPi(Double)	Вычисляет arc-cosine значения и делит результат на pi.
Asin(Double)	Вычисляет arc-sine значения.
Asinh(Double)	Вычисляет гиперболический arc-sine значения.
AsinPi(Double)	Вычисляет arc-sine значения и делит результат на pi.
Atan(Double)	Вычисляет дуго-тангенс значения.
Atan2(Double, Double)	Вычисляет дуго-тангенс кворента двух значений.
Atan2Pi(Double, Double)	Вычисляет дуго-тангенс для кворента двух значений и делит результат на pi.
Atanh(Double)	Вычисляет гиперболический дуговой тангенс значения.
AtanPi(Double)	Вычисляет дуго-тангенс значения и делит результат на pi.
BitDecrement(Double)	Возвращает наибольшее значение, которое сравнивает меньше указанного значения.
BitIncrement(Double)	Возвращает наименьшее значение, которое сравнивает больше указанного значения.
Cbrt(Double)	Вычисляет корень куба значения.
Ceiling(Double)	Вычисляет потолок значения.
Clamp(Double, Double, Double)	Зацепляет значение к инклюзивному минимальному и максимальному значению.
ClampNative(Double, Double, Double)	Зацепляет значение к инклюзивному минимальному и максимальному значению, используя поведение, зависящее от платформы, и NaNNegativeZero.
CompareTo(Double)	Сравнивает этот экземпляр с указанным числом с плавающей запятой двойной точности и возвращает целое число, указывающее, меньше ли значение этого экземпляра, равное или больше заданного числа с плавающей запятой двойной точности.
CompareTo(Object)	Сравнивает этот экземпляр с указанным объектом и возвращает целое число, указывающее, меньше ли значение этого экземпляра, равно или больше значения указанного объекта.
ConvertToInteger<TInteger>(Double)	Преобразует значение в указанный целочисленный тип, используя насыщенность при переполнении
ConvertToIntegerNative<TInteger>(Double)	Преобразует значение в указанный целочисленный тип, используя конкретное поведение платформы при переполнении.
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 на определенную мощность и вычитает один.
Exp2(Double)	Вычисления, поднятые 2 на определенную мощность.
Exp2M1(Double)	Вычисления, поднятые 2 на определенную мощность и вычитает один.
ExpM1(Double)	Вычисления, поднятые E на определенную мощность и вычитает один.
Floor(Double)	Вычисляет пол значения.
FusedMultiplyAdd(Double, Double, Double)	Вычисляет умноженное умножение трех значений.
GetHashCode()	Возвращает хэш-код для этого экземпляра.
GetTypeCode()	TypeCode Возвращает тип Doubleзначения.
Hypot(Double, Double)	Вычисляет гипотенуз с двумя значениями, представляющими длину более коротких сторон в правом углу треугольника.
Ieee754Remainder(Double, Double)	Вычисляет оставшуюся часть двух значений, указанных IEEE 754.
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)	Определяет, является ли значение двумя.
IsRealNumber(Double)	Определяет, представляет ли значение реальное число.
IsSubnormal(Double)	Определяет, является ли указанное значение ненормальным.
Lerp(Double, Double, Double)	Выполняет линейную интерполяцию между двумя значениями на основе заданного веса.
Log(Double, Double)	Вычисляет логарифм значения в указанной базе.
Log(Double)	Вычисляет естественный (base-E логарифм значения).
Log10(Double)	Вычисляет логарифм базового-10 значения.
Log10P1(Double)	Вычисляет логарифм базового-10 значения плюс один.
Log2(Double)	Вычисляет журнал 2 значения.
Log2P1(Double)	Вычисляет логарифм базового-2 значения плюс один.
LogP1(Double)	Вычисляет естественный (base-E) логарифм значения плюс один.
Max(Double, Double)	Сравнивает два значения с вычислениями, которые больше.
MaxMagnitude(Double, Double)	Сравнивает два значения с вычислениями, которые больше.
MaxMagnitudeNumber(Double, Double)	Сравнивает два значения с вычислениями, которые имеют большую величину и возвращают другое значение, если входные данные.NaN
MaxNative(Double, Double)	Сравнивает два значения с вычислениями, которые больше используют поведение NaN для конкретной платформы и NegativeZero.
MaxNumber(Double, Double)	Сравнивает два значения с вычислениями, которые больше и возвращают другое значение, если входные данные.NaN
Min(Double, Double)	Сравнивает два значения с вычислениями, которые меньше.
MinMagnitude(Double, Double)	Сравнивает два значения с вычислениями, которые меньше.
MinMagnitudeNumber(Double, Double)	Сравнивает два значения с вычислениями, которые имеют меньшую величину и возвращают другое значение, если входные данные.NaN
MinNative(Double, Double)	Сравнивает два значения с вычислениями, которые меньше используют поведение NaN для конкретной платформы и NegativeZero.
MinNumber(Double, Double)	Сравнивает два значения с вычислениями, которые меньше и возвращают другое значение, если входные данные имеют NaNзначение.
MultiplyAddEstimate(Double, Double, Double)	Вычисляет оценку (left * right) + . addend
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует диапазон символов, содержащий строковое представление числа в заданном стиле и формате языка и региональных параметров, в эквивалент числа с плавающей запятой двойной точности.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате языка и региональных параметров в эквивалентное число с плавающей запятой двойной точности.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентное число с плавающей запятой двойной точности.
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном стиле в эквивалент числа с плавающей запятой двойной точности.
Parse(String)	Преобразует строковое представление числа в эквивалент числа с плавающей запятой двойной точности.
Pow(Double, Double)	Вычисляет значение, возвращаемое заданной мощностью.
RadiansToDegrees(Double)	Преобразует заданное значение из радианов в градусы.
ReciprocalEstimate(Double)	Вычисляет оценку взаимности значения.
ReciprocalSqrtEstimate(Double)	Вычисляет оценку обратного квадратного корня значения.
RootN(Double, Int32)	Вычисляет корень n-го значения.
Round(Double, Int32, MidpointRounding)	Округляет значение до указанного числа дробных цифр с помощью режима округления по умолчанию (ToEven).
Round(Double, Int32)	Округляет значение до указанного числа дробных цифр с помощью режима округления по умолчанию (ToEven).
Round(Double, MidpointRounding)	Округляет значение до ближайшего целого числа с помощью указанного режима округления.
Round(Double)	Округляет значение до ближайшего целого числа с помощью режима округления по умолчанию (ToEven).
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, IFormatProvider)	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление, используя указанный формат и сведения о формате, зависящее от языка и региональных параметров.
ToString(String)	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление, используя указанный формат.
Truncate(Double)	Усечение значения.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего двойного экземпляра в предоставленный диапазон символов.
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)	Возвращает значение, указывающее, равны ли два указанных Double значения.
GreaterThan(Double, Double)	Возвращает значение, указывающее, больше ли указанное Double значение, чем другое указанное Double значение.
GreaterThanOrEqual(Double, Double)	Возвращает значение, указывающее, больше ли указанное Double значение или равно другому указанному Double значению.
Inequality(Double, Double)	Возвращает значение, указывающее, равны ли два указанных Double значения.
LessThan(Double, Double)	Возвращает значение, указывающее, меньше ли указанное Double значение, чем другое указанное Double значение.
LessThanOrEqual(Double, Double)	Возвращает значение, указывающее, меньше ли указанное Double значение или равно другому указанному Double значению.

Явные реализации интерфейса

Имя	Описание
IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	Добавляет два значения вместе для вычисления суммы.
IAdditiveIdentity<Double,Double>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryNumber<Double>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	Вычисляет битовое и два значения.
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	Вычисляет битовое или два значения.
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	Вычисляет монопольные или два значения.
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	Вычисляет представление заданного значения с дополнением.
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)	Делит одно значение на другое, чтобы вычислить их кворот.
IFloatingPoint<Double>.GetExponentByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Double>.GetExponentShortestBitLength()	Возвращает длину (в битах) в кратчайшем представлении двух дополнений текущего экспонента.
IFloatingPoint<Double>.GetSignificandBitLength()	Возвращает длину (в битах) текущего знака.
IFloatingPoint<Double>.GetSignificandByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Пытается написать текущую экспоненту в формате big-endian в заданном диапазоне.
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Пытается написать текущий экспонент в малоконечном формате в заданном диапазоне.
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Пытается написать текущий знак в формате big-endian в заданном диапазоне.
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)	Делит два значения вместе, чтобы вычислить их модулу или оставшуюся часть.
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	Возвращает умножающее удостоверение текущего типа.
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	Умножает два значения вместе, чтобы вычислить свой продукт.
INumberBase<Double>.IsCanonical(Double)	Определяет, находится ли значение в его каноническом представлении.
INumberBase<Double>.IsComplexNumber(Double)	Определяет, представляет ли значение сложное число.
INumberBase<Double>.IsImaginaryNumber(Double)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<Double>.IsZero(Double)	Определяет, равно ли значение нулю.
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)	Вычитает два значения, чтобы вычислить их разницу.
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	Вычисляет унарное отрицание значения.
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	Вычисляет унарный плюс значения.

Потокобезопасность

Все члены этого типа являются потокобезопасны. Элементы, которые, как представляется, изменяют состояние экземпляра, фактически возвращают новый экземпляр, инициализированный с новым значением. Как и в случае с любым другим типом, чтение и запись в общую переменную, которая содержит экземпляр этого типа, должна быть защищена блокировкой, чтобы гарантировать безопасность потока.

См. также раздел

• Decimal
• Single
• Пример: программа форматирования WinForms для .NET Core (C#)
• Пример: программа форматирования WinForms для .NET Core (Visual Basic)