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.402823e38 から正の 3.402823e38 までの値を持つ単精度の 32 ビット数値を表し、正または負のゼロ、および数値 ( ) ではありません PositiveInfinity NegativeInfinity NaN 。 これは、非常に大きい値 (惑星や惑星間の距離など) または非常に小さい値 (キログラム単位の分子の塊など) を表し、不正確である (地球から別の太陽系への距離など) ことが多い値を表す目的です。 型 Single は、バイナリ浮動小数点演算の IEC 60559:1989 (IEEE 754) 標準に準拠しています。

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

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

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

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

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

小数部が一部の小数部の値 (1/3 や など) を正確に表すのと同様に、二項小数部は一部の小数部の値 Math.PI を表す必要があります。 たとえば、小数部として .2 で正確に表される 2/10 は、.0011111001001100 で二項小数として表され、パターン "1100" は無限大に繰り返されます。 この場合、浮動小数点値は、それが表す数値の不正確な表現を提供します。 元の浮動小数点値に対して追加の算術演算を実行すると、多くの場合、精度の欠如が増加します。 たとえば、.3 を 10 で乗算し、9 回 .3 を .3 に加算した結果を比較すると、乗算よりも 8 個多くの演算が含まれるため、加算によって生成される結果が少ないのが分かっています。 この不一致は、"R" 標準の数値書式指定文字列 を使用して 2 つの値を表示する場合にのみ明らかです。必要に応じて、型でサポートされている Single 有効桁数が 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

一部の数値は小数部のバイナリ値として正確に表現できないので、浮動小数点数は近似実数にしか使用できません。

すべての浮動小数点数の有効桁数は限られています。浮動小数点値が実際の数値にどの程度正確に近似しているかも決定します。 値 Single の有効桁数は最大 7 桁ですが、最大 9 桁は内部的に保持されます。 つまり、浮動小数点演算によっては、浮動小数点値を変更する有効桁数が不足している可能性があります。 次の例では、大きな単精度浮動小数点値を定義し、 と 1 つの Single.Epsilon quadrillion の製品を追加します。 ただし、製品が小さすぎて元の浮動小数点値を変更する必要があります。 最も重要な数字は 1/000 です。一方、製品の最も重要な数字は 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).
    

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

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

    小数部の値を使用した数値演算の精度が重要な場合は、 型ではなく 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 にキャストされた後、2 つの値の比較では、値が等 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
    

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

等しいかのテスト

等しいと見なされるには、2 つの Single 値が同一の値を表す必要があります。 ただし、値間の精度の違い、または一方または両方の値による有効桁数の損失により、同一と見なされる浮動小数点値は、多くの場合、最も小さい数字の差が原因で等しくないことが示されます。 その結果、2 つの値が等しいかどうかを判断するために メソッドを呼び出します。または、 メソッドを呼び出して 2 つの値間の関係を判断すると、予期しない結果が生じる Equals CompareTo Single 場合があります。 これは次の例で明らかです。2 つの明らかに等しい値は等しくないと見なされます。最初の値の有効桁数は 7 桁で、2 番目の値は 9 です。 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 つの値が 2 乗され、元の値を復元するために平方根 Single が計算されます。 2 番目の は 3.51 で乗算され、結果の平方根を 3.51 で割って元の値を復元する前に 2 乗 Single されます。 2 つの値は同一のように見えますが、 メソッドの呼び出しは Equals(Single) 、等しくないと示します。 "G9" 標準書式指定文字列を使用して、各値のすべての有効桁数を表示する結果文字列を返す場合は、2 番目の値が最初の値より Single 小さい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.Round び出して、両方の値の有効桁数が同じことを確認します。 次の例では、前の例を変更して、この方法を使用して、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 は、等しいかテストするときに、2 つの値間の距離の Single 絶対測定値として使用される場合があります。 ただし、 は、値が 0 の に追加または減算できる最小の Single.Epsilon Single 値を測定します。 ほとんどの正の値と負の値では、 の SingleSingle.Epsilon が小さすぎて検出されません。 したがって、0 の値を除き、等しい値をテストで使用することをお勧めしません。

    次の例では、後者の方法を使用して、2 つの値の相対的な差を IsApproximatelyEqual テストするメソッドを定義します。 また、 メソッドと メソッドの呼び出しの 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、正の無限大、負の無限大、または数値 (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 PositiveInfinitySingle.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# には cast 演算子が必要であることに注意してください。
はい。 Decimal 29桁の有効桁数をサポートします。は Single 9 をサポートします。
Double 絞り範囲外の値は、またはに変換され Double.NegativeInfinity Double.PositiveInfinity ます。 はい。 Double は、有効桁数が17桁の10進数をサポートします。は 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桁の有効桁数をサポートします。は 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.NaN Double.PositiveInfinity Double.NegativeInfinity Single.NaN 、それぞれ、、およびに変換さ Single.PositiveInfinity Single.NegativeInfinity れます。

数値型の値を値に変換すると、有効桁数が失われる可能性があることに注意して Single ください。 例に示すように、、、 Decimal Double 、、 Int32 Int64 UInt32 、およびの UInt64 値を値に Single 変換する場合、精度が低下する可能性があります。

値からへの変換 Single は、 Double 拡大変換です。 型の値が正確に表現されていない場合、変換によって精度が低下する可能性があり Double Single ます。

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

変換後の型 結果
任意の整数型 OverflowExceptionChecked コンテキストで変換が発生した場合の例外。

(C# の既定の) unchecked コンテキストで変換が行われた場合、変換操作は成功しますが、値はオーバーフローします。
Decimal 例外です。 OverflowException

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

有効桁数が失われると、値が別の数値型に変換される可能性があることに注意して Single ください。 整数以外の値を変換する場合 Single 、例の出力が示すように、 Single 値が丸められるか (Visual Basic)、または切り捨てられたとき (C# の場合)、小数部分は失われます。 値への変換では、 Decimal Single 対象のデータ型で値の正確な表現が得られない場合があります。

次の例では、 Single いくつかの値を他の数値型に変換します。 変換は、Visual Basic (既定値) および C# ( checkedキーワードによる) で checked コンテキストで実行されます。 この例の出力は、チェックされていないコンテキストでの変換の結果を示しています。 コンパイラスイッチを使用してコンパイルすることによって、 /removeintchecks+ または C# でステートメントをコメントアウトすることで、Visual Basic の unchecked コンテキストで変換を実行でき 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構造体と関連する型には、次のカテゴリの操作を実行するメソッドが用意されています。

  • 値の比較。 メソッドを呼び出して Equals 、2つの値が等しいかどうかを判断するか、 Single CompareTo 2 つの値の間のリレーションシップを決定するメソッドを呼び出すことができます。

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

    警告

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

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

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

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

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

  • 丸め。 丸めは、浮動小数点表現と精度の問題によって生じる値の違いを減らすための手法としてよく使用されます。 値は、 Single メソッドを呼び出すことによって丸めることができ Math.Round ます。 ただし、 Single メソッドが呼び出される前に値がに変換され、変換に精度が失われる可能性があることに注意して Double ください。

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

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

  • 型変換Single構造体は、 IConvertible 任意の2つの標準 .NET Framework データ型間の変換をサポートするインターフェイスの明示的なインターフェイスの実装を提供します。 言語コンパイラでは、を値に変換する以外に、他のすべての標準数値型の値の暗黙的な変換もサポートされて Double Single います。 以外の標準数値型の値から a への変換 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)」をご覧ください。

適用対象

スレッド セーフ

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

こちらもご覧ください