Single 構造体

定義

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

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
public value class float : IComparable, IConvertible, IFormattable
public value class float : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
type single = struct
    interface IConvertible
    interface IFormattable
type single = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type single = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type single = struct
    interface IFormattable
    interface IConvertible
type single = struct
    interface IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), ISpanFormattable
Public Structure Single
Implements IComparable, IConvertible, IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable
継承
Single
属性
実装

注釈

Single値型は、負の 3.402823 e38 から正の 3.402823 e38 までの値を持ち、正または負の0、 PositiveInfinity 、、() ではない値を持つ単精度32ビットの数値を表し NegativeInfinity NaN ます。 これは、非常に大きな値 (惑星または galaxies 間の距離など) または非常に小さい値 (キログラムの物質の分子質量など) を表すことを目的としており、多くの場合、(地球から別の太陽システムへの距離など) 不正確になることがあります。 この Single 型は、バイナリ浮動小数点演算の IEC 60559:1989 (IEEE 754) 標準に準拠しています。

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

System.Single この型のインスタンスを比較し、インスタンスの値をその文字列形式に変換し、数値の文字列形式をこの型のインスタンスに変換するメソッドを提供します。 書式指定コードによる値型の文字列形式の制御方法の詳細については、「 型の書式設定」、「 標準の数値書式指定文字列」、および「 カスタム数値書式指定文字列」を参照してください。

浮動小数点表現と有効桁数

データ型では、 Single 次の表に示すように、単精度浮動小数点値が32ビットのバイナリ形式で格納されます。

パーツ Bits
有効桁または仮数 0-22
指数 23-30
符号 (0 = 正、1 = 負) 31

10分の分数では、一部の小数部 (1/3 やなど) を正確に表すことができないのと同様に Math.PI 、バイナリの分数では小数部の値を表すことができません。 たとえば、10進数として0.2 によって正確に表される2/10 は、0011111001001100によって "1100" というパターンの無限大点として表されます。 この場合、浮動小数点値は、それが表す数値の不正確な表現を提供します。 多くの場合、元の浮動小数点値に対して追加の数学演算を実行すると、精度が高くなります。 たとえば、.3 と10を乗算した結果を比較し、.3 を. 3 9 回追加した場合、乗算よりも8個の操作が含まれているため、加算によってより正確な結果が得られないことがわかります。 この不均衡は、 Single "R" 標準の数値書式指定文字列を使用して2つの値を表示した場合にのみわかります。これは、必要に応じて、型でサポートされている9桁すべての有効桁数を表示し Single ます。

using System;

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

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

一部の数値は小数部のバイナリ値として正確に表すことができないため、浮動小数点数は実数のみを概数にすることができます。

すべての浮動小数点数には、有効桁数が制限されています。これにより、浮動小数点値が実数を近似する精度も決まります。 値には最大7桁の有効桁数が Single ありますが、内部的には最大9桁が保持されます。 これは、浮動小数点演算によっては、浮動小数点値を変更するための有効桁数が不足している場合があることを意味します。 次の例では、大きな単精度浮動小数点値を定義し、の積 Single.Epsilon と1つの quadrillion を追加します。 ただし、元の浮動小数点値を変更するには、製品が小さすぎます。 最下位桁は1000桁ですが、製品の最上位桁は 10-30です。

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123.456f;
      Single additional = Single.Epsilon * 1e15f;
      Console.WriteLine($"{value} + {additional} = {value + additional}");
   }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456
Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

浮動小数点数の有効桁数には、次のような結果があります。

  • 特定の有効桁数で等しく見える 2 つの浮動小数点数が、最小有効数字が異なっているために等しくない場合があります。 次の例では、一連の数値が加算され、それらの合計が予想される合計と比較されます。 2つの値は同じように見えますが、メソッドを呼び出すと、その値 Equals がではないことが示されます。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          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 (27.65) does not equal the total (27.65).   
    //
    // 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.6500015) does not equal the total (27.65).
    
    Module Example
       Public Sub Main()
          Dim values() As Single = { 10.01, 2.88, 2.88, 2.88, 9.0 }
          Dim result As Single = 27.65
          Dim total As Single
          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 (27.65) does not equal the total (27.65).   
    '
    ' 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} 2 つの値のすべての有効桁数を表示すると Single 、加算演算中に精度が低下しているため、2つの値が等しくないことが明らかになります。 この場合、比較を実行する前に、メソッドを呼び出して、値を目的の精度に丸めることによって問題を解決でき Math.Round(Double, Int32) Single ます。

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

    小数部の値を持つ数値演算の精度が重要な場合は、 Decimal 型の代わりに型を使用し Single ます。 型または型の範囲を超える整数値を持つ数値演算の精度 Int64 UInt64 が重要な場合は、型を使用し BigInteger ます。

  • 浮動小数点数が含まれている場合、値はラウンドトリップしない可能性があります。 値は、操作が元の浮動小数点数を別の形式に変換した場合、逆の演算で変換後の形式から浮動小数点数に変換した後、最後の浮動小数点数が元の浮動小数点数と等しい場合に、ラウンドトリップと呼ばれます。 変換で1つ以上の有効桁が失われたり、変更されたりすると、ラウンドトリップが失敗する可能性があります。 次の例では、3つの Single 値が文字列に変換され、ファイルに保存されます。 出力に示されているように、値は同じように見えますが、復元された値は元の値と同じではありません。

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.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.882883 <> 2.882883
    //       0.3333333 <> 0.3333333
    //       3.141593 <> 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write(values(ctr).ToString())
             If ctr <> values.Length - 1 Then sw.Write("|")
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '        2.882883 <> 2.882883
    '        0.3333333 <> 0.3333333
    '        3.141593 <> 3.141593
    

    この場合、次の例に示すように、値の完全な有効桁数を保持するために "G9" 標準の数値書式指定文字列 を使用すると、値が正常にラウンドトリップされることがあり Single ます。

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
          
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.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.882883 = 2.882883
    //       0.3333333 = 0.3333333
    //       3.141593 = 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write("{0:G9}{1}", values(ctr), 
                      If(ctr < values.Length - 1, "|", ""))
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       2.882883 = 2.882883
    '       0.3333333 = 0.3333333
    '       3.141593 = 3.141593
    
  • Single 値の有効桁数が Double 値を下回っています。 Single多くの場合、一見同等の値に変換される値は、 Double 精度が異なるため、値と等しくありません Double 。 次の例では、同じ除算演算の結果が値と値に割り当てられてい Double Single ます。 Single値がにキャストされた後 Double 、2つの値の比較によって等しくないことが示されます。

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

    この問題を回避するには、 Double データ型の代わりにデータ型を使用するか、メソッドを使用して Single 両方の値の Round 有効桁数を同じにします。

等しいかどうかのテスト

等しいと見なされるためには、2つの Single 値が同一の値を表す必要があります。 ただし、値間の精度に違いがあるため、または1つまたは両方の値によって精度が低下しているため、同一であることが予想される浮動小数点値は、少なくとも有効桁数が異なるために等しくないと見なされることがよくあります。 結果として、 Equals 2 つの値が等しいかどうかを判断するためにメソッドを呼び出し、2つの値の間の関係を判断するためにメソッドを呼び出すと、 CompareTo 多くの場合、 Single 予期しない結果が発生します。 次の例では、最初の値の有効桁数が7桁で、2番目の値が9であるため、2つの一見等しい Single 値が等しくないことがわかります。

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False
Module Example
   Public Sub Main()
      Dim value1 As Single = .3333333
      Dim value2 As Single = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

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

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389
Module Example
   Public Sub Main()
      Dim value1 As Single = 10.201438
      value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
      Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
      value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

精度の低下が比較の結果に影響を与える可能性がある場合は、メソッドまたはメソッドを呼び出す代わりに、次の方法を使用でき Equals CompareTo ます。

  • Math.Round2 つの値の有効桁数が同じであることを確認するには、メソッドを呼び出します。 次の例では、この方法を使用するように前の例を変更し、2つの小数部の値が等価になるようにしています。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = .3333333f;
          float value2 = 1.0f/3;
          int precision = 7;
          value1 = (float) Math.Round(value1, precision);
          value2 = (float) 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
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = .3333333
          Dim value2 As Single = 1/3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.3333333 = 0.3333333: True
    

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

  • 等しいかどうかをテストします。 この手法では、2つの値が異なる一方でも同じであるか、またはより小さい値が大きな値から逸脱する相対金額を定義する必要があります。

    警告

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

    次の例では、後者の方法を使用して、 IsApproximatelyEqual 2 つの値の相対差をテストするメソッドを定義しています。 また、メソッドとメソッドの呼び出しの結果も比較し IsApproximatelyEqual Equals(Single) ます。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1f;
    
          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, .000001f));   
       }
    
       static bool IsApproximatelyEqual(float value1, float value2, float 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 = 1.00000012: False
    //       1 is approximately equal to 1.00000012: True
    
    Module Example
       Public Sub Main()
          Dim one1 As Single = .1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
             one2 += CSng(.1)
          Next
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001))   
       End Sub
    
       Function IsApproximatelyEqual(value1 As Single, value2 As Single, 
                                     epsilon As Single) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
          
          ' Handle NaN, Infinity.
          If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
             Return value1.Equals(value2)
          Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
             Return value1.Equals(value2)
          End If
          
          ' Handle zero to avoid division by zero
          Dim divisor As Single = 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 = 1.00000012: False
    '       1 is approximately equal to 1.00000012: True
    

浮動小数点値と例外

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

  • 浮動小数点演算の結果が変換先の形式に対して小さすぎる場合、結果は0になります。 これは、次の例に示すように、非常に小さい2つの浮動小数点数を乗算した場合に発生する可能性があります。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
       }
    }
    // The example displays the following output:
    //       1.163287E-36 * 9.164234E-25 = 0
    //       0 = 0: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 1.163287e-36
          Dim value2 As Single = 9.164234e-25
          Dim result As Single = value1 * value2
          Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
       End Sub
    End Module
    ' The example displays the following output:
    '       1.163287E-36 * 9.164234E-25 = 0
    '       0 = 0: True
    
  • 浮動小数点演算の結果の大きさが変換先の形式の範囲を超える場合、演算の結果は、 PositiveInfinity NegativeInfinity 結果の符号に応じてまたはになります。 次の例に示すように、オーバーフローする操作の結果 Single.MaxValue PositiveInfinity と、オーバーフローする操作の結果はになり Single.MinValue NegativeInfinity ます。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Single.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 3.065e35
          Dim value2 As Single = 6.9375e32
          Dim result As Single = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
          Console.WriteLine()                  
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
       End Sub
    End Module
    ' The example displays the following output:
    '       PositiveInfinity: True
    '       NegativeInfinity: False
    '       
    '       PositiveInfinity: False
    '       NegativeInfinity: True
    

    PositiveInfinity また、0による正の被除数の除算によって結果が得ら NegativeInfinity れ、0による除算の結果が負の被除数と共に返されます。

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

    • 被除数が0の0による除算。 0による除算のその他のケースでは、またはのいずれかになり PositiveInfinity NegativeInfinity ます。

    • 無効な入力を伴う浮動小数点演算。 たとえば、負の値の平方根を検索しようとすると、が返さ NaN れます。

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

型変換と単一の構造体

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

次の表は、他のプリミティブ数値型の値を値に変換できること Single を示しています。また、変換が拡大または縮小であるかどうか、および結果として得られる精度が元の値よりも少ないかどうかも示してい Single ます。

変換 ( 拡大/縮小 有効桁数が失われる可能性があります
Byte Widening いいえ
Decimal Widening

C# にはキャスト演算子が必要です。
はい。 Decimal は、有効桁数が 29 桁の 10 進数をサポートします。 Single は 9 をサポートしています。
Double 縮小。範囲外の値は、 または に変換 Double.NegativeInfinity されます Double.PositiveInfinity はい。 Double では、有効桁数が 17 桁サポートされています。 Single は 9 をサポートしています。
Int16 Widening いいえ
Int32 Widening はい。 Int32 では、有効桁数が 10 桁です。 Single は 9 をサポートしています。
Int64 Widening はい。 Int64 は、有効桁数が 19 桁の 10 進数をサポートします。 Single は 9 をサポートしています。
SByte Widening いいえ
UInt16 Widening いいえ
UInt32 Widening はい。 UInt32 では、有効桁数が 10 桁です。 Single は 9 をサポートしています。
UInt64 Widening はい。 Int64 は、有効桁数が 20 桁の 10 進数をサポートします。 Single は 9 をサポートしています。

次の例では、他のプリミティブ数値型の最小値または最大値を 値に変換 Single します。

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      float sngValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal) ||
             value.GetType() == typeof(Double))
            sngValue = (float) value;
         else
            sngValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)
Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim sngValue As Single
      For Each value In values
         If value.GetType() = GetType(Double) Then
            sngValue = CSng(value)
         Else
            sngValue = value
         End If
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

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

一部の数値型の値を値に変換すると、有効桁数が失 Single われる可能性があります。 例に示すように、 の各値を値に変換すると、有効桁数 Decimal Double Int32 Int64 UInt32 UInt64 が失われる可能性 Single があります。

値から への Single 変換 Double は拡大変換です。 型に値の正確な表現が含されていない場合、変換によって有効桁数 Double が失われる可能性 Single があります。

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

変換後の型 結果
任意の整数型 チェック OverflowException されたコンテキストで変換が発生した場合の例外。

変換がチェックされていないコンテキスト (C# の既定値) で発生した場合、変換操作は成功しますが、値はオーバーフローします。
Decimal 例外 OverflowException

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

有効桁数が失われると、値が別の数値型 Single に変換される可能性があります。 非整数値を変換する場合、例の出力に示すように、小数部の部分は、値が丸められたり (Visual Basic のように) 切り捨てられたり Single すると失われます (C# の場合と同様 Single )。 値への変換 Decimal の場合、値がターゲット データ型に Single 正確な表現を持たない場合があります。

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

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Long = 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

         Dim dblValue As Double = value
         Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

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

浮動小数点の機能

構造体 Single と関連する型は、次のカテゴリの操作を実行するメソッドを提供します。

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

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

    警告

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

    、、、および IsNaN メソッドを IsInfinityIsPositiveInfinityIsNegativeInfinity 出して、これらの特殊な値をテストすることもできます。

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

    他の数学的演算を実行するには、 クラスで static ( Shared Visual Basic) メソッドを呼び出 System.Math します。 これには、算術演算に一般的に使用される追加のメソッド (、 など)、geometry (や など)、および微円 Math.Abs Math.Sign (など) Math.Sqrt Math.Cos Math.Sin が含まれます Math.Log 。 すべての場合、値は Single に変換されます Double

    値内の個々のビットを操作 Single できます。 メソッド BitConverter.GetBytes(Single) は、バイト配列内のビット パターンを返します。 そのバイト配列を メソッドに渡して、値のビット パターンを BitConverter.ToInt32 Single 32 ビット整数で保持できます。

  • の丸め。 丸めは、多くの場合、浮動小数点表現と精度の問題によって引き起こされる値間の差の影響を軽減する手法として使用されます。 メソッドを呼び出 Single すことによって、値を丸 Math.Round めできます。 ただし、 メソッドが呼び出される前に 値が に変換され、変換の精度が失われる Single Double 可能性があります。

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

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

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

    ただし、32 ビットと 64 ビットの整数値の変換には、有効桁数の損失が伴う可能性があります。 次の表に、32 ビット、64 ビット、および型の有効桁数の違いを示 Double します。

    種類 最大有効桁数 (10 進数) 内部有効桁数 (10 進数)
    Double 15 17
    Int32 および UInt32 10 10
    Int64 および UInt64 19 19
    Single 7 9

    精度の問題は、 Single 値に変換される値に最も頻繁に影響を及ぼし Double ます。 次の例では、同じ除算演算によって生成される2つの値が等しくありません。値の1つがに変換される単精度浮動小数点値であるため 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
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

フィールド

Epsilon

ゼロより大きい最小の Single 値を表します。 このフィールドは定数です。

MaxValue

Single の最大有効値を表します。 このフィールドは定数です。

MinValue

Single の最小有効値を表します。 このフィールドは定数です。

NaN

非数 (NaN) を表します。 このフィールドは定数です。

NegativeInfinity

負の無限大を表します。 このフィールドは定数です。

PositiveInfinity

正の無限大を表します。 このフィールドは定数です。

メソッド

CompareTo(Object)

このインスタンスと指定したオブジェクトを比較し、このインスタンスの値が指定したオブジェクトの値よりも小さいか、同じか、または大きいかを示す整数を返します。

CompareTo(Single)

このインスタンスと指定した単精度浮動小数点数を比較し、このインスタンスの値が指定した単精度浮動小数点数の値よりも小さいか、同じか、それとも大きいかを示す整数を返します。

Equals(Object)

このインスタンスが指定されたオブジェクトに等しいかどうかを示す値を返します。

Equals(Single)

このインスタンスと指定した Single オブジェクトが同じ値を表しているかどうかを示す値を返します。

GetHashCode()

このインスタンスのハッシュ コードを返します。

GetTypeCode()

Single 値型の TypeCode を返します。

IsFinite(Single)

指定した値が有限 (ゼロ、非正規、または正規) かどうかを判断します。

IsInfinity(Single)

指定した数値が負または正の無限大と評価されるかどうかを示す値を返します。

IsNaN(Single)

指定した値が非数値 (NaN) かどうかを示す値を返します。

IsNegative(Single)

指定した値が負かどうかを判断します。

IsNegativeInfinity(Single)

指定した数値が負の無限大と評価されるかどうかを示す値を返します。

IsNormal(Single)

指定した値が正規かどうかを判断します。

IsPositiveInfinity(Single)

指定した数値が正の無限大と評価されるかどうかを示す値を返します。

IsSubnormal(Single)

指定した値が非正規かどうかを判断します。

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

指定したスタイルおよびカルチャに固有の書式による数値の文字列表現を含む文字スパンを、それと等価な単精度浮動小数点数に変換します。

Parse(String)

数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。

Parse(String, IFormatProvider)

指定したカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。

Parse(String, NumberStyles)

指定したスタイルでの数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。

Parse(String, NumberStyles, IFormatProvider)

指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。

ToString()

このインスタンスの数値を、それと等価な文字列形式に変換します。

ToString(IFormatProvider)

このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。

ToString(String)

指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。

ToString(String, IFormatProvider)

このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

現在の浮動小数点数インスタンスの値の、指定した文字スパンへの書式設定を試みます。

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

指定したスタイルおよびカルチャに固有の書式による数値のスパン表現を、それと等価な単精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。

TryParse(ReadOnlySpan<Char>, Single)

文字スパン内の数値の文字列表現を、それと等価の単精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。

TryParse(String, NumberStyles, IFormatProvider, Single)

指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。

TryParse(String, Single)

数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。 戻り値は変換が成功したか失敗したかを示します。

演算子

Equality(Single, Single)

指定した 2 つの Single 値が等しいかどうかを示す値を返します。

GreaterThan(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値より大きいかどうかを示す値を返します。

GreaterThanOrEqual(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値以上かどうかを示す値を返します。

Inequality(Single, Single)

指定した 2 つの Single 値が等しくないかどうかを示す値を返します。

LessThan(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値より小さいかどうかを示す値を返します。

LessThanOrEqual(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値以下かどうかを示す値を返します。

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

IComparable.CompareTo(Object)

現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスの並べ替え順序での位置が、比較対象のオブジェクトと比べて前か、後か、または同じかを示す整数を返します。

IConvertible.GetTypeCode()

インスタンスの TypeCode を返します。

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)」をご覧ください。

適用対象

スレッド セーフ

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

こちらもご覧ください