이 문서는 기계로 번역한 것입니다. 원본 텍스트를 보려면 포인터를 문서의 문장 위로 올리십시오. 추가 정보
번역
원본
정보
요청한 주제가 아래에 표시됩니다. 그러나 이 주제는 이 라이브러리에 포함되지 않습니다.

Double 구조체

배정밀도 부동 소수점 숫자를 나타냅니다.

네임스페이스:  System
어셈블리:  mscorlib(mscorlib.dll)

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

Double 형식에서는 다음과 같은 멤버를 노출합니다.

  이름설명
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원CompareTo(Double)이 인스턴스를 지정된 배정밀도 부동 소수점 숫자와 비교하고 이 인스턴스의 값이 지정된 배정밀도 부동 소수점 숫자 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.
Public 메서드XNA Framework에서 지원CompareTo(Object)이 인스턴스를 지정된 개체와 비교하고 이 인스턴스의 값이 지정된 개체의 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Equals(Double)이 인스턴스의 값과 지정된 Double 개체의 값이 같은지 여부를 나타내는 값을 반환합니다.
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Equals(Object)이 인스턴스가 지정된 개체와 같은지 여부를 나타내는 값을 반환합니다. (ValueType.Equals(Object)을(를) 재정의함)
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원GetHashCode이 인스턴스의 해시 코드를 반환합니다. (ValueType.GetHashCode()을(를) 재정의함)
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원GetType현재 인스턴스의 Type을 가져옵니다. (Object에서 상속됨)
Public 메서드XNA Framework에서 지원GetTypeCode Double 값 형식에 대한 TypeCode를 반환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원IsInfinity지정된 숫자가 음의 무한대로 계산되는지 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원IsNaN지정된 값이 숫자(NaN)가 아닌지 여부를 나타내는 값을 반환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원IsNegativeInfinity지정된 숫자가 음의 무한대로 계산되는지를 나타내는 값을 반환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원IsPositiveInfinity지정된 숫자가 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Parse(String)숫자의 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Parse(String, NumberStyles)지정된 스타일의 숫자에 대한 문자열 표현을 해당하는 배정밀도 부동 소수점 숫자로 변환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Parse(String, IFormatProvider)지정된 문화권별 형식의 숫자에 대한 문자열 표현을 해당하는 배정밀도 부동 소수점 숫자로 변환합니다.
Public 메서드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Parse(String, NumberStyles, IFormatProvider)지정된 스타일 및 문화권별 형식의 숫자에 대한 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다.
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원ToString()이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다. (ValueType.ToString()을(를) 재정의함)
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원ToString(IFormatProvider)지정된 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원ToString(String)지정된 형식을 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.
Public 메서드XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원ToString(String, IFormatProvider)지정된 형식 및 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.
Public 메서드정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원TryParse(String, Double)숫자의 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다.
Public 메서드정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원TryParse(String, NumberStyles, IFormatProvider, Double)지정된 스타일 및 문화권별 형식의 숫자에 대한 문자열 표현을 같은 값의 배정밀도 부동 소수점 숫자로 변환합니다. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다.
위쪽

  이름설명
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Equality지정된 두 Double 값이 같은지 여부를 나타내는 값을 반환합니다.
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원GreaterThan지정된 Double 값이 지정된 다른 Double 값보다 큰지 여부를 나타내는 값을 반환합니다.
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원GreaterThanOrEqual지정된 Double 값이 지정된 다른 Double 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Inequality지정된 두 Double 값이 같지 않은지 여부를 나타내는 값을 반환합니다.
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원LessThan지정된 Double 값이 지정된 다른 Double 값보다 작은지 여부를 나타내는 값을 반환합니다.
Public 연산자정적 멤버이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원LessThanOrEqual지정된 Double 값이 지정된 다른 Double 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.
위쪽

  이름설명
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원Epsilon0보다 큰 양의 최소 Double 값을 나타냅니다. 이 필드는 상수입니다.
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원MaxValue Double 의 최대값을 나타냅니다. 이 필드는 상수입니다.
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원MinValue Double 의 최소값을 나타냅니다. 이 필드는 상수입니다.
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원NaNNot-a-Number(NaN)를 나타냅니다. 이 필드는 상수입니다.
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원NegativeInfinity음의 무한대를 나타냅니다. 이 필드는 상수입니다.
Public 필드정적 멤버XNA Framework에서 지원이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원PositiveInfinity양의 무한대를 나타냅니다. 이 필드는 상수입니다.
위쪽

  이름설명
명시적 인터페이스 구현Private 메서드이식 가능한 클래스 라이브러리에서 지원Windows 스토어 앱용 .NET에서 지원IComparable.CompareTo현재 인스턴스와 동일한 형식의 다른 개체를 비교하고 정렬 순서에서 현재 인스턴스의 위치가 다른 개체보다 앞인지, 뒤인지 또는 동일한지를 나타내는 정수를 반환합니다.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToBoolean인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToBoolean을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToByte인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToByte를 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToChar인프라입니다. 이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToDateTime인프라입니다. 이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToDecimal인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToDecimal을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToDouble인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToDouble을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToInt16인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToInt16을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToInt32인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToInt32를 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToInt64인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToInt64를 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToSByte인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToSByte를 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToSingle인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToSingle을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToType인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToType을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToUInt16인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToUInt16을 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToUInt32인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToUInt32를 참조하십시오.
명시적 인터페이스 구현Private 메서드XNA Framework에서 지원IConvertible.ToUInt64인프라입니다. 이 멤버에 대한 설명은 IConvertible.ToUInt64를 참조하십시오.
위쪽

이러한 Double 값 형식은 배정밀도 64비트 숫자를 나타내며, 음수 1.79769313486232e308과 양수 1.79769313486232e308 사이의 값을 가지고, 양수 또는 음수 0, PositiveInfinity, NegativeInfinity 및 Not-a-Number(NaN)도 포함됩니다. (킬로그램의 물질의 분자 질량) 매우 작은 또는 매우 큰 (예: 은하계 행성 사이 거리)와 자주 정확 하지 않습니다 (예: 거리 지구에서 다른 태양계에) 값을 표시 하는 Double 종류는 IEC 60559: 1989 (IEEE 754) 이진 부동 소수점 연산에 대한 표준을 준수합니다.

이 항목은 다음과 같은 단원으로 구성됩니다.

부동 소수점 표시 및 정밀도

이러한 Double 데이터 형식이 다음 표에 나와 있는 것 처럼 이중 정밀도 부동 소수점 값 64 비트이진 형식으로 저장 합니다.

파트

비트

기호 또는 수

0-51

지수

52-62

기호 (0 = 양수, 1 = 음수)

63

일부 소수 값을 정확하게 표현할 수 없습니다. (1/3과 같거나 Math.PI), 이진 분수는 일부 소수 값을 나타낼 수 없습니다. 예를 들어,.001100110011 패턴 "0011" 반복 무한대로 있는 이진 분수를 소수로.1 통해 정확 하 게 표시 되며, 1/10 표시 됩니다. 이러한 경우, 부동 소수점 값은 표현하는 숫자의 부정확한 표현을 제공합니다. 종종 원래 부동 소수점 값에 산술 연산을 추가로 수행 하는 정밀도 부족을 증가 경향이 있습니다. 예를 들어, 1에 10을 곱한 결과와 1에 1을 아홉번 더한 값을 비교할 경우, 이러한 비교를 우린 볼 수 있습니다. 왜냐하면 8 이상의 연산을 포함하기 때문에, 간단하게 결과를 생성할 수 있습니다. 이러한 차이는 분명합니다. 이는 만약 두개의 Double 값을 표준 수 형식 문자열 인 "R"을 사용함으로써 나타낼 경우, 필요한경우입니다. Double 형식에 의해 지원되는 모든 정밀도의 17 숫자들을 표시합니다.


using System;

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

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


일부 숫자는 이진 소수값으로서 정확하게 표현되지 않을수도 있기 때문에, 부동 소수점 숫자는 오직 대략적인 실제 수치입니다.

또한 모든 부동 소수점 숫자는 유효 숫자의 제한된 수를 갖습니다, 이는 정확하게 부동 소수점 값이 실제 수에 어떻게 접근하는지 결정합니다. 이 Double 값은 15자리 10진수 정밀도에 가깝습니다, 비록 17자리 10진수의 최대치가 내부적으로 유지됩니다. 이것은 일부 부동 소수점 연산은 부동 소수점 값을 변경하기 위해 정밀도가 부족함을 의미합니다. 다음 예제에서 이에 대해 설명합니다. 매우 큰 부동 소수점 값을 정의하고 다음 Double.Epsilon 상품을 추가하고 1000조를 추가합니다. 그러나, 이 제품은 너무 작아서 원래 부동소수점 값을 수정합니다. 가장 적게 유효한 수는 천이며 반면에 가장 충분히 유효한 수는 1-312입니다.


using System;

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


부동 소수점 숫자의 제한된 정밀도에 따라 다음과 같은 여러 경우가 발생합니다.

  • 특정 정밀도에 대해 동일하게 나타나는 두 개의 부동 소수점 숫자는 최소 유효 자릿수가 다르기 때문에 서로 다른 것으로 간주될 수 있습니다. 다음 예제에서, 수의 연속은 서로를 추가시키고 그들의 전체는 그들의 예상된 전체수와 비교됩니다. 비록 두 값이 동일하게 보일지라도, Equals 메서드 호출은 그들이 존재하지 않다는 것을 예시합니다.

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

    만일 Console.WriteLine(String, Object, Object) 명세서는 {0}{1} 에서 {0:R}{1:R} 으로부터 모든 유효한 수를 두 Double 값을 나타내기 위하여, 형식 항목을 변경할 경우, 두 값은 부가적인 작업동안 정밀도 손실 때문에 동일하지 않습니다. 이러한 경우, 이슈는 Math.Round(Double, Int32) 메서드를 Double 값을 원하는 정밀도로 호출하기 함으로써 해결할 수 있습니다.

  • 부동 소수점 숫자를 사용하는 수학 연산이나 비교 연산에서는 이진 부동 소수점 숫자로 동일한 10진수를 정확하게 나타낼 수 없기 때문에 10진수가 사용되는 경우 동일한 결과를 생성하지 않을 수 있습니다. 이전 예제는이 곱하기 10 여.1.1 번 추가 결과 표시 하 여 보여 줍니다.

    소수 값이 수식 연산에 정밀도 중요 한 경우는 Decimal 대신 Double 형식입니다. 수 연산에서 정수 값을 사용한 Int64 또는 UInt64 형식의 범위를 벗어나서 정확도가 중요해질 때, BigInteger 형식을 사용합니다.

  • 부동 소수점 숫자가 포함된 경우 값에 왕복이 발생하지 않을 수 있습니다. 연산에서 원래 부동 소수점 숫자를 다른 형식으로 변환하고, 역 연산에서 변환된 형식을 다시 부동 소수점 숫자로 변환하며, 최종 부동 소수점 숫자가 원래 부동 소수점 숫자와 같지 않으면 해당 값을 왕복값이라고 합니다. 변환할 때 하나 이상의 최소 유효 자릿수가 손실되거나 변경되기 때문에 라운드트립이 실패할 수 있습니다. 다음 예제에서는 세 가지 Double 값이 문자열로 변환되고 파일에 저장합니다. 그러나, 볼 수 있듯이 출력 값이 동일하게 보일 수도 있지만, 복원 된 값이 원래 값과 같습니다.

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

    이러한 경우, 값은 성공적으로 왕복할 수 있습니다. 이는 표준 수 형식 문자열 인 "R"을 전체 정밀도인 Double 값을 보호하기 위하여 사용합니다. 다음 예제를 보십시오.

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
    
    
  • Single 값 보다 낮은 정밀도 Double 값입니다. Single 값은 겉보기에 동등한 Double 를 전환한 값입니다 이 값은 종종 Double 값과 동일하지 않은데, 다른 정밀도 값때문입니다. 동일한 나누기 작업의 결과에 할당 된 다음 예제에서는 Double 값과 Single 값입니다. Single 값을 Double 로 캐스팅한 후, 두 값의 비교는 동일하지 않음을 보여줍니다.

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

    이 문제를 방지하려면, 둘 다는 Double 데이터 형식을 Single 데이터 형식이 놓여진 곳에서 사용합니다, 또는 Round 메서드를 사용합니다. 그 결과 두 값은 동일한 정밀도를 가집니다.

또한 Double 값을 사용한 산술 및 할당 연산의 결과는 Double 형식의 전체 자릿수 손실로 인해 플랫폼마다 약간씩 다를 수 있습니다. 예를 들어, 리터럴 Double 값을 할당한 결과는 .NET 프레임워크의 32-비트 및 64-비트 버전에 따라 달라질 수 있습니다. 다음 예제에는 -4.42330604244772E-305의 리터럴 값 및 -4.42330604244772E-305 값의 변수가 Double 변수에 할당될 때 그 차이를 설명합니다. 이 경우에는 Parse(String) 메서드의 결과는 정밀도가 저하되지 않습니다.


double value = -4.42330604244772E-305;

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

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


같음 여부 테스트

동일한 조건에서, 두 Double 값에 동일한 값을 나타내야 합니다. 그러나 값의 정밀도 차이 때문에 또는 하나 또는 두 개의 값으로 정밀도 손실 때문에 종종 동일한 것으로 간주 됩니다 부동 소수점 값으로 판명되며, 최하위 유효 자릿수의 차이 때문에 서로 다릅니다. 이러한 결과로서, Equals 메서드 호출은 두 값이 동일한지 결정하기 위해 또는 CompareTo 메서드 호출은 두 Double 값 사이의 관계를 결정하기 위함이며, 종종 예기치 않은 결과를 야기합니다. 이는 다음 예제에서 증거입니다, 명백하게 두 동일한 Double 값은 동일하지 않음을 판명하며, 첫 번째 값은 15 수의 정밀도를 갖기 때문이며, 두번째 값이 9를 갖지 않기 때문입니다.


using System;

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


다른 코드 경로인 값과 다른 방법으로 조작된 계산된 값은 다른 방법으로 종종 동일하지 않음을 입증합니다. 다음 예제에서, 하나의 Double 값을 제곱하고 제곱근을 계산 후 원래 값으로 복원 합니다. 두 번째 Double 는 3.51을 곱하고, 결과의 제곱 루트를 3.51로 나누기 전에 제곱은 원래 값으로 복원합니다. 비록 두 값이 동일하게 보일지라도, Equals(Double) 메서드 호출은 그들이 동일하게 존재하지 않다는 것을 예시합니다. "R" 표준 서식 문자열을 사용하여 각각의 Double 값의 모든 유효 자릿수를 표시하는 결과로서, 문자열을 반환 값의 두 번째 값.0000000000001 임을 보여 주며 이는 첫 번째 보다 작습니다.


using System;

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


정밀도 손실 비교의 결과 영향을 줄 가능성이 높은 경우에 호출 하는 다음 방법 중 하나 채택할 수 있습니다.는 Equals 또는 CompareTo 메서드:

  • Math.Round 메서드를 두 값이 동일한 정밀도를 가짐을 확신하기 위해 호출합니다. 다음 예제에서는 소수 두 값이 같으면 이 접근 방식을 사용하는 이전 예제를 수정합니다.

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

    정밀도 문제가 여전히 중간점 값을 반올림 하여 적용 되는 지 참고합니다. 자세한 내용은 Math.Round(Double, Int32, MidpointRounding) 메서드를 참조하십시오.

  • 대략 같음 테스트를 대신 같음. 이러한 기술은 두 값이 다를수 있는 절대적인 총량을 정의하는 이러한 사실을 필요로하지만, 여전히 동일하거나 또는 더 작은 값을 큰 값으로 부터 나눈 상대적인 총량을 정의합니다.

    주의 정보주의

    일치 테스트를 하는 경우, Double.Epsilon 는 때때로 두 Double 값 사이 거리의 절대적인 총량으로서 사용됩니다. 그러나, Double.Epsilon 는 값이 0인 Double 로부터 빼거나 더해질 수 있는 가장 작은 가능한 값을 측정합니다. 대부분의 양수 및 음수 Double 값에 대하여, Double.Epsilon 의 값은 너무 작아서 감지하기 어렵습니다. 그러므로 0 값을 제외하고는 일치에 대한 테스트에서 사용합니다.

    다음 예제에서는 후자의 방법을 사용하여 정의된 IsApproximatelyEqual 두 값 사이의 상대적인 차이를 테스트하는 방법입니다. IsApproximatelyEqual 메서드 및 Equals(Double) 메서드에 대해 호출하는 결과를 대비합니다.

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

부동 소수점 값 및 예외

부동 소수점 값을 사용한 작업 오버플로 또는 0으로 나누기 같이 잘못된 작업의 경우에 예외를 쓰로우하는 정수 계열 형식과 달리 예외를 쓰로우하지 않습니다. 대신 이러한 경우 부동 소수점 연산의 결과 0, 양의 무한대, 음의 무한대 또는 not-a-number (NaN):

  • 부동 소수점 연산의 결과가 대상 형식에 비해 너무 작으면 연산 결과는 0입니다. 다음 예제와 같이 두 개의 매우 작은 부동 소수점 숫자를 곱할 때 발생할 수 있습니다.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
       }
    }
    // The example displays the following output:
    //       1.16328759815342E-225 * 9.1642346778E-175 = 0
    //       0 = 0: True
    
    
    
  • 부동 소수점 연산의 결과가 대상 형식에 비해 범위가 초과되면 연산 결과는 결과의 부호에 따라 PositiveInfinity 또는 NegativeInfinity입니다. 오버플로 작업 Double.MaxValuePositiveInfinity, 및 오버플로 연산의 결과 Double.MinValueNegativeInfinity다음 예제와 같습니다.

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

    PositiveInfinity 는 또한 양의 피제수를 0으로 나눈 결과 및 NegativeInfinity 음수 배당금을 0으로 나눈 결과입니다.

  • 부동 소수점 연산이 잘못되었으면 연산 결과는 NaN입니다. 예를 들어, NaN 다음 작업으로부터 발생합니다.

  • 잘못된 입력을 사용한 모든 부동 소수점 연산입니다. 예를 들어, 호출의 Math.Sqrt 음수 값을 가진 메서드 NaN전화 처럼의 Math.Acos 값 보다 하나 크거나 작으면 음수 1을 사용 하 여 메서드.

  • 인수 값이 있는 작업 Double.NaN입니다.

부동 소수점 함수

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 Framework 데이터 형식 간의 변환을 지원합니다. 언어 컴파일러는 또한 다른 모든 표준 숫자 형식으로 값의 암시적 변환이 지원 Double 값입니다. 값 이외의 모든 표준 숫자 형식을 변환 하는 Double 에 는 확대 변환하고 캐스팅 연산자나 변환 메서드를 사용하지 않습니다.

    그러나 변환 Int64Single 값 정밀도 손실 될 수 있습니다. 다음 표에서 32 비트 64 비트 각각의 정밀도 차이 및 유형:

    형식

    최대 정밀도

    내부 정밀도

    Double

    15

    17

    Int64

    19자리 10진수

    19자리 10진수

    Single

    7자리 10진수

    9자리 10진수

    정밀도 문제는 대부분 Single 값에 영향을 미칩니다. 이는 Double 값을 변환합니다. 다음 예제에서는 동일한 나누기 연산에 의해 발생 하는 두 개의 값이 같지 않습니다. 왜냐하면 변환된 단 정밀도 부동 소수점 값인 Double 를 변환시킨 값중 하나이기 때문입니다.

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

다음 코드 예제에서는 Double을 사용합니다.


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

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

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

			return m_value.ToString(format, provider);
		}

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

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

			return temp;
		}

		// The value holder
		protected double m_value;

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

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


.NET Framework

4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0에서 지원

.NET Framework Client Profile

4, 3.5 SP1에서 지원

이식 가능한 클래스 라이브러리

이식 가능한 클래스 라이브러리에서 지원

Windows 스토어 앱용 .NET

Windows 8에서 지원

Windows Phone 앱용 .NET

Windows Phone 8, Silverlight 8.1에서 지원

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008(서버 코어 역할은 지원되지 않음), Windows Server 2008 R2(서버 코어 역할은 SP1 이상에서 지원, Itanium은 지원되지 않음)

.NET Framework에서 모든 플랫폼의 전체 버전을 지원하지는 않습니다. 지원되는 버전의 목록을 보려면 .NET Framework 시스템 요구 사항을 참조하십시오.

이 형식의 모든 멤버는 스레드로부터 안전합니다. 인스턴스 상태를 수정하는 것처럼 보이는 멤버의 경우 실제로는 새 값으로 초기화되는 새 인스턴스를 반환합니다. 다른 모든 형식과 마찬가지로 이 형식의 인스턴스를 포함하는 공유 변수를 읽고 쓰는 작업은 스레드로부터 안전하도록 잠가서 보호해야 합니다.

주의 정보주의

이 형식의 인스턴스를 할당하는 경우 해당 인스턴스의 이진 표현이 너무 커서 단일 원자 연산에 할당되지 못할 수 있으므로 모든 하드웨어 플랫폼에서 스레드로부터 안전하지 않습니다.

커뮤니티 추가 항목

표시:
© 2015 Microsoft