Single 構造体

定義

単精度浮動小数点数を表します。Represents a single-precision floating-point number.

public value class Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public value class Single : IComparable, IConvertible, IFormattable
public value class Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
[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
[<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, 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 ます。The Single value type represents a single-precision 32-bit number with values ranging from negative 3.402823e38 to positive 3.402823e38, as well as positive or negative zero, PositiveInfinity, NegativeInfinity, and not a number (NaN). これは、非常に大きな値 (惑星または galaxies 間の距離など) または非常に小さい値 (キログラムの物質の分子質量など) を表すことを目的としており、多くの場合、(地球から別の太陽システムへの距離など) 不正確になることがあります。It is intended to represent values that are extremely large (such as distances between planets or galaxies) or extremely small (such as the molecular mass of a substance in kilograms) and that often are imprecise (such as the distance from earth to another solar system). この Single 型は、バイナリ浮動小数点演算の IEC 60559:1989 (IEEE 754) 標準に準拠しています。The Single type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

このトピックは、次のセクションで構成されています。This topic consists of the following sections:

System.Single この型のインスタンスを比較し、インスタンスの値をその文字列形式に変換し、数値の文字列形式をこの型のインスタンスに変換するメソッドを提供します。System.Single provides methods to compare instances of this type, to convert the value of an instance to its string representation, and to convert the string representation of a number to an instance of this type. 書式指定コードによる値型の文字列形式の制御方法の詳細については、「 型の書式設定」、「 標準の数値書式指定文字列」、および「 カスタム数値書式指定文字列」を参照してください。For information about how format specification codes control the string representation of value types, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.

浮動小数点表現と有効桁数Floating-point representation and precision

データ型では、 Single 次の表に示すように、単精度浮動小数点値が32ビットのバイナリ形式で格納されます。The Single data type stores single-precision floating-point values in a 32-bit binary format, as shown in the following table:

パーツPart BitsBits
有効桁または仮数Significand or mantissa 0-220-22
指数Exponent 23-3023-30
符号 (0 = 正、1 = 負)Sign (0 = positive, 1 = negative) 3131

10分の分数では、一部の小数部 (1/3 やなど) を正確に表すことができないのと同様に Math.PI 、バイナリの分数では小数部の値を表すことができません。Just as decimal fractions are unable to precisely represent some fractional values (such as 1/3 or Math.PI), binary fractions are unable to represent some fractional values. たとえば、10進数として0.2 によって正確に表される2/10 は、0011111001001100によって "1100" というパターンの無限大点として表されます。For example, 2/10, which is represented precisely by .2 as a decimal fraction, is represented by .0011111001001100 as a binary fraction, with the pattern "1100" repeating to infinity. この場合、浮動小数点値は、それが表す数値の不正確な表現を提供します。In this case, the floating-point value provides an imprecise representation of the number that it represents. 多くの場合、元の浮動小数点値に対して追加の数学演算を実行すると、精度が高くなります。Performing additional mathematical operations on the original floating-point value often increases its lack of precision. たとえば、.3 と10を乗算した結果を比較し、.3 を. 3 9 回追加した場合、乗算よりも8個の操作が含まれているため、加算によってより正確な結果が得られないことがわかります。For example, if you compare the results of multiplying .3 by 10 and adding .3 to .3 nine times, you will see that addition produces the less precise result, because it involves eight more operations than multiplication. この不均衡は、 Single "R" 標準の数値書式指定文字列を使用して2つの値を表示した場合にのみわかります。これは、必要に応じて、型でサポートされている9桁すべての有効桁数を表示し Single ます。Note that this disparity is apparent only if you display the two Single values by using the "R" standard numeric format string, which, if necessary, displays all 9 digits of precision supported by the Single type.

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

一部の数値は小数部のバイナリ値として正確に表すことができないため、浮動小数点数は実数のみを概数にすることができます。Because some numbers cannot be represented exactly as fractional binary values, floating-point numbers can only approximate real numbers.

すべての浮動小数点数には、有効桁数が制限されています。これにより、浮動小数点値が実数を近似する精度も決まります。All floating-point numbers have a limited number of significant digits, which also determines how accurately a floating-point value approximates a real number. 値には最大7桁の有効桁数が Single ありますが、内部的には最大9桁が保持されます。A Single value has up to 7 decimal digits of precision, although a maximum of 9 digits is maintained internally. これは、浮動小数点演算によっては、浮動小数点値を変更するための有効桁数が不足している場合があることを意味します。This means that some floating-point operations may lack the precision to change a floating-point value. 次の例では、大きな単精度浮動小数点値を定義し、の積 Single.Epsilon と1つの quadrillion を追加します。The following example defines a large single-precision floating-point value, and then adds the product of Single.Epsilon and one quadrillion to it. ただし、元の浮動小数点値を変更するには、製品が小さすぎます。However, the product is too small to modify the original floating-point value. 最下位桁は1000桁ですが、製品の最上位桁は 10-30です。Its least significant digit is thousandths, whereas the most significant digit in the product is 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

浮動小数点数の有効桁数には、次のような結果があります。The limited precision of a floating-point number has several consequences:

  • 特定の有効桁数で等しく見える 2 つの浮動小数点数が、最小有効数字が異なっているために等しくない場合があります。Two floating-point numbers that appear equal for a particular precision might not compare equal because their least significant digits are different. 次の例では、一連の数値が加算され、それらの合計が予想される合計と比較されます。In the following example, a series of numbers are added together, and their total is compared with their expected total. 2つの値は同じように見えますが、メソッドを呼び出すと、その値 Equals がではないことが示されます。Although the two values appear to be the same, a call to the Equals method indicates that they are not.

    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つの値が等しくないことが明らかになります。If you change the format items in the Console.WriteLine(String, Object, Object) statement from {0} and {1} to {0:R} and {1:R} to display all significant digits of the two Single values, it is clear that the two values are unequal because of a loss of precision during the addition operations. この場合、比較を実行する前に、メソッドを呼び出して、値を目的の精度に丸めることによって問題を解決でき Math.Round(Double, Int32) Single ます。In this case, the issue can be resolved by calling the Math.Round(Double, Int32) method to round the Single values to the desired precision before performing the comparison.

  • 浮動小数点数を使用する数学的演算または比較演算では、10進数が使用されている場合、同じ結果が得られないことがあります。これは、バイナリ浮動小数点数が10進数と等しくない可能性があるためです。A mathematical or comparison operation that uses a floating-point number might not yield the same result if a decimal number is used, because the binary floating-point number might not equal the decimal number. 前の例では、.3 に10を乗算し、.3 を. 3 9 回に加算した結果を表示しています。A previous example illustrated this by displaying the result of multiplying .3 by 10 and adding .3 to .3 nine times.

    小数部の値を持つ数値演算の精度が重要な場合は、 Decimal 型の代わりに型を使用し Single ます。When accuracy in numeric operations with fractional values is important, use the Decimal type instead of the Single type. 型または型の範囲を超える整数値を持つ数値演算の精度 Int64 UInt64 が重要な場合は、型を使用し BigInteger ます。When accuracy in numeric operations with integral values beyond the range of the Int64 or UInt64 types is important, use the BigInteger type.

  • 浮動小数点数が含まれている場合、値はラウンドトリップしない可能性があります。A value might not round-trip if a floating-point number is involved. 値は、操作が元の浮動小数点数を別の形式に変換した場合、逆の演算で変換後の形式から浮動小数点数に変換した後、最後の浮動小数点数が元の浮動小数点数と等しい場合に、ラウンドトリップと呼ばれます。A value is said to round-trip if an operation converts an original floating-point number to another form, an inverse operation transforms the converted form back to a floating-point number, and the final floating-point number is equal to the original floating-point number. 変換で1つ以上の有効桁が失われたり、変更されたりすると、ラウンドトリップが失敗する可能性があります。The round trip might fail because one or more least significant digits are lost or changed in a conversion. 次の例では、3つの Single 値が文字列に変換され、ファイルに保存されます。In the following example, three Single values are converted to strings and saved in a file. 出力に示されているように、値は同じように見えますが、復元された値は元の値と同じではありません。As the output shows, although the values appear to be identical, the restored values are not equal to the original values.

    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 ます。In this case, the values can be successfully round-tripped by using the "G9" standard numeric format string to preserve the full precision of Single values, as the following example shows.

    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 values have less precision than Double values. Single多くの場合、一見同等の値に変換される値は、 Double 精度が異なるため、値と等しくありません DoubleA Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. 次の例では、同じ除算演算の結果が値と値に割り当てられてい Double Single ます。In the following example, the result of identical division operations is assigned to a Double value and a Single value. Single値がにキャストされた後 Double 、2つの値の比較によって等しくないことが示されます。After the Single value is cast to a Double, a comparison of the two values shows that they are unequal.

    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 有効桁数を同じにします。To avoid this problem, either use the Double data type in place of the Single data type, or use the Round method so that both values have the same precision.

等しいかどうかのテストTesting for equality

等しいと見なされるためには、2つの Single 値が同一の値を表す必要があります。To be considered equal, two Single values must represent identical values. ただし、値間の精度に違いがあるため、または1つまたは両方の値によって精度が低下しているため、同一であることが予想される浮動小数点値は、少なくとも有効桁数が異なるために等しくないと見なされることがよくあります。However, because of differences in precision between values, or because of a loss of precision by one or both values, floating-point values that are expected to be identical often turn out to be unequal due to differences in their least significant digits. 結果として、 Equals 2 つの値が等しいかどうかを判断するためにメソッドを呼び出し、2つの値の間の関係を判断するためにメソッドを呼び出すと、 CompareTo 多くの場合、 Single 予期しない結果が発生します。As a result, calls to the Equals method to determine whether two values are equal, or calls to the CompareTo method to determine the relationship between two Single values, often yield unexpected results. 次の例では、最初の値の有効桁数が7桁で、2番目の値が9であるため、2つの一見等しい Single 値が等しくないことがわかります。This is evident in the following example, where two apparently equal Single values turn out to be unequal, because the first value has 7 digits of precision, whereas the second value has 9.

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

異なるコードパスに従い、異なる方法で操作される計算値は、多くの場合、等しくないことが証明されます。Calculated values that follow different code paths and that are manipulated in different ways often prove to be unequal. 次の例では、1つの Single 値が二乗で、平方根が計算され、元の値が復元されます。In the following example, one Single value is squared, and then the square root is calculated to restore the original value. 2番目の Single は、結果の平方根が3.51 で除算され、元の値が復元される前に、3.51 と二乗が乗算されます。A second Single is multiplied by 3.51 and squared before the square root of the result is divided by 3.51 to restore the original value. 2つの値は同一であるように見えますが、メソッドを呼び出すと、それらの値 Equals(Single) が等しくないことが示されます。Although the two values appear to be identical, a call to the Equals(Single) method indicates that they are not equal. "G9" 標準書式指定文字列を使用して、各値のすべての有効桁数を表示する結果文字列を返すと、 Single 2 番目の値が .0000000000001 未満であることが示されます。Using the "G9" standard format string to return a result string that displays all the significant digits of each Single value shows that the second value is .0000000000001 less than the first.

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 ます。In cases where a loss of precision is likely to affect the result of a comparison, you can use the following techniques instead of calling the Equals or CompareTo method:

  • Math.Round2 つの値の有効桁数が同じであることを確認するには、メソッドを呼び出します。Call the Math.Round method to ensure that both values have the same precision. 次の例では、この方法を使用するように前の例を変更し、2つの小数部の値が等価になるようにしています。The following example modifies a previous example to use this approach so that two fractional values are equivalent.

    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
    

    精度の問題は、中間値の丸めにも適用されることに注意してください。Note that the problem of precision still applies to rounding of midpoint values. 詳細については、Math.Round(Double, Int32, MidpointRounding) メソッドを参照してください。For more information, see the Math.Round(Double, Int32, MidpointRounding) method.

  • 等しいかどうかをテストします。Test for approximate equality instead of equality. この手法では、2つの値が異なる一方でも同じであるか、またはより小さい値が大きな値から逸脱する相対金額を定義する必要があります。This technique requires that you define either an absolute amount by which the two values can differ but still be equal, or that you define a relative amount by which the smaller value can diverge from the larger value.

    警告

    Single.Epsilon は、 Single 等しいかどうかをテストするときに2つの値の間の距離の絶対測定値として使用されることがあります。Single.Epsilon is sometimes used as an absolute measure of the distance between two Single values when testing for equality. ただし、は、 Single.Epsilon 値がゼロであるに加算または減算できる最小値を測定し Single ます。However, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. 正および負の値について Single は、の値 Single.Epsilon が小さすぎて検出できません。For most positive and negative Single values, the value of Single.Epsilon is too small to be detected. したがって、値がゼロの場合を除いて、等しいかどうかのテストでは使用しないことをお勧めします。Therefore, except for values that are zero, we do not recommend its use in tests for equality.

    次の例では、後者の方法を使用して、 IsApproximatelyEqual 2 つの値の相対差をテストするメソッドを定義しています。The following example uses the latter approach to define an IsApproximatelyEqual method that tests the relative difference between two values. また、メソッドとメソッドの呼び出しの結果も比較し IsApproximatelyEqual Equals(Single) ます。It also contrasts the result of calls to the IsApproximatelyEqual method and the Equals(Single) method.

    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
    

浮動小数点値と例外Floating-point values and exceptions

浮動小数点値を使用した操作は、整数型の演算とは異なり、例外をスローしません。これは、0除算やオーバーフローなどの無効な操作が発生した場合に例外をスローします。Operations with floating-point values do not throw exceptions, unlike operations with integral types, which throw exceptions in cases of illegal operations such as division by zero or overflow. 代わりに、このような状況では、浮動小数点演算の結果は0、正の無限大、負の無限大、または非数 (NaN) になります。Instead, in these situations, the result of a floating-point operation is zero, positive infinity, negative infinity, or not a number (NaN):

  • 浮動小数点演算の結果が変換先の形式に対して小さすぎる場合、結果は0になります。If the result of a floating-point operation is too small for the destination format, the result is zero. これは、次の例に示すように、非常に小さい2つの浮動小数点数を乗算した場合に発生する可能性があります。This can occur when two very small floating-point numbers are multiplied, as the following example shows.

    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 結果の符号に応じてまたはになります。If the magnitude of the result of a floating-point operation exceeds the range of the destination format, the result of the operation is PositiveInfinity or NegativeInfinity, as appropriate for the sign of the result. 次の例に示すように、オーバーフローする操作の結果 Single.MaxValue PositiveInfinity と、オーバーフローする操作の結果はになり Single.MinValue NegativeInfinity ます。The result of an operation that overflows Single.MaxValue is PositiveInfinity, and the result of an operation that overflows Single.MinValue is NegativeInfinity, as the following example shows.

    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による除算の結果が負の被除数と共に返されます。PositiveInfinity also results from a division by zero with a positive dividend, and NegativeInfinity results from a division by zero with a negative dividend.

  • 浮動小数点演算が無効な場合、演算の結果はに NaN なります。If a floating-point operation is invalid, the result of the operation is NaN. たとえば、 NaN 次の操作の結果が返されます。For example, NaN results from the following operations:

    • 被除数が0の0による除算。Division by zero with a dividend of zero. 0による除算のその他のケースでは、またはのいずれかになり PositiveInfinity NegativeInfinity ます。Note that other cases of division by zero result in either PositiveInfinity or NegativeInfinity.

    • 無効な入力を伴う浮動小数点演算。Any floating-point operation with invalid input. たとえば、負の値の平方根を検索しようとすると、が返さ NaN れます。For example, attempting to find the square root of a negative value returns NaN.

    • 値がである引数を持つすべての操作 Single.NaNAny operation with an argument whose value is Single.NaN.

型変換と単一の構造体Type conversions and the Single structure

Single構造体は、明示的または暗黙的な変換演算子を定義しません。代わりに、変換はコンパイラによって実装されます。The Single structure does not define any explicit or implicit conversion operators; instead, conversions are implemented by the compiler.

次の表は、他のプリミティブ数値型の値を値に変換できること Single を示しています。また、変換が拡大または縮小であるかどうか、および結果として得られる精度が元の値よりも少ないかどうかも示してい Single ます。The following table lists the possible conversions of a value of the other primitive numeric types to a Single value, It also indicates whether the conversion is widening or narrowing and whether the resulting Single may have less precision than the original value.

変換 (Conversion from 拡大/縮小Widening/narrowing 有効桁数が失われる可能性がありますPossible loss of precision
Byte WideningWidening いいえNo
Decimal WideningWidening

C# には cast 演算子が必要であることに注意してください。Note that C# requires a cast operator.
はい。Yes. Decimal 29桁の有効桁数をサポートします。は Single 9 をサポートします。Decimal supports 29 decimal digits of precision; Single supports 9.
Double 絞り範囲外の値は、またはに変換され Double.NegativeInfinity Double.PositiveInfinity ます。Narrowing; out-of-range values are converted to Double.NegativeInfinity or Double.PositiveInfinity. はい。Yes. Double は、有効桁数が17桁の10進数をサポートします。は Single 9 をサポートします。Double supports 17 decimal digits of precision; Single supports 9.
Int16 WideningWidening いいえNo
Int32 WideningWidening はい。Yes. Int32 10進数の有効桁数をサポートします。は Single 9 をサポートします。Int32 supports 10 decimal digits of precision; Single supports 9.
Int64 WideningWidening はい。Yes. Int64 有効桁数が19桁の10進数をサポートします。は Single 9 をサポートします。Int64 supports 19 decimal digits of precision; Single supports 9.
SByte WideningWidening いいえNo
UInt16 WideningWidening いいえNo
UInt32 WideningWidening はい。Yes. UInt32 10進数の有効桁数をサポートします。は Single 9 をサポートします。UInt32 supports 10 decimal digits of precision; Single supports 9.
UInt64 WideningWidening はい。Yes. Int64 20桁の有効桁数をサポートします。は Single 9 をサポートします。Int64 supports 20 decimal digits of precision; Single supports 9.

次の例では、他のプリミティブ数値型の最小値または最大値を値に変換し Single ます。The following example converts the minimum or maximum value of other primitive numeric types to a Single value.

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 れます。In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity convert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

数値型の値を値に変換すると、有効桁数が失われる可能性があることに注意して Single ください。Note that the conversion of the value of some numeric types to a Single value can involve a loss of precision. 例に示すように、、、 Decimal Double 、、 Int32 Int64 UInt32 、およびの UInt64 値を値に Single 変換する場合、精度が低下する可能性があります。As the example illustrates, a loss of precision is possible when converting Decimal, Double, Int32, Int64, UInt32, and UInt64 values to Single values.

値からへの変換 Single は、 Double 拡大変換です。The conversion of a Single value to a Double is a widening conversion. 型の値が正確に表現されていない場合、変換によって精度が低下する可能性があり Double Single ます。The conversion may result in a loss of precision if the Double type does not have a precise representation for the Single value.

値から以外の Single プリミティブ数値データ型の値への変換 Double は縮小変換であり、キャスト演算子 (C# の場合) または変換メソッド (Visual Basic) が必要です。The conversion of a Single value to a value of any primitive numeric data type other than a Double is a narrowing conversion and requires a cast operator (in C#) or a conversion method (in Visual Basic). 対象のデータ型の範囲外の値 (対象の型のおよびプロパティによって定義される) は MinValue MaxValue 、次の表に示すように動作します。Values that are outside the range of the target data type, which are defined by the target type's MinValue and MaxValue properties, behave as shown in the following table.

変換後の型Target type 結果Result
任意の整数型Any integral type OverflowExceptionChecked コンテキストで変換が発生した場合の例外。An OverflowException exception if the conversion occurs in a checked context.

(C# の既定の) unchecked コンテキストで変換が行われた場合、変換操作は成功しますが、値はオーバーフローします。If the conversion occurs in an unchecked context (the default in C#), the conversion operation succeeds but the value overflows.
Decimal 例外です。 OverflowExceptionAn OverflowException exception,

また、、、およびは、 Single.NaN Single.PositiveInfinity checked コンテキスト Single.NegativeInfinity OverflowException で整数への変換のためにをスローしますが、これらの値は unchecked コンテキストで整数に変換されるとオーバーフローします。In addition, Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity throw an OverflowException for conversions to integers in a checked context, but these values overflow when converted to integers in an unchecked context. への変換で Decimal は、常にをスロー OverflowException します。For conversions to Decimal, they always throw an OverflowException. への変換では、 Double それぞれ、、およびに変換さ Double.NaN Double.PositiveInfinity Double.NegativeInfinity れます。For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

有効桁数が失われると、値が別の数値型に変換される可能性があることに注意して Single ください。Note that a loss of precision may result from converting a Single value to another numeric type. 整数以外の値を変換する場合 Single 、例の出力が示すように、 Single 値が丸められるか (Visual Basic)、または切り捨てられたとき (C# の場合)、小数部分は失われます。In the case of converting non-integral Single values, as the output from the example shows, the fractional component is lost when the Single value is either rounded (as in Visual Basic) or truncated (as in C#). 値への変換では、 Decimal Single 対象のデータ型で値の正確な表現が得られない場合があります。For conversions to Decimal values, the Single value may not have a precise representation in the target data type.

次の例では、 Single いくつかの値を他の数値型に変換します。The following example converts a number of Single values to several other numeric types. 変換は、Visual Basic (既定値) および C# ( checked キーワードによる) で checked コンテキストで実行されます。The conversions occur in a checked context in Visual Basic (the default) and in C# (because of the checked keyword). この例の出力は、チェックされていないコンテキストでの変換の結果を示しています。The output from the example shows the result for conversions in both a checked an unchecked context. コンパイラスイッチを使用してコンパイルすることによって、 /removeintchecks+ または C# でステートメントをコメントアウトすることで、Visual Basic の unchecked コンテキストで変換を実行でき checked ます。You can perform conversions in an unchecked context in Visual Basic by compiling with the /removeintchecks+ compiler switch and in C# by commenting out the checked statement.

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 および型変換テーブル型変換」を参照してください。For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

浮動小数点機能Floating-point functionality

Single構造体と関連する型には、次のカテゴリの操作を実行するメソッドが用意されています。The Single structure and related types provide methods to perform the following categories of operations:

  • 値の比較Comparison of values. メソッドを呼び出して Equals 、2つの値が等しいかどうかを判断するか、 Single CompareTo 2 つの値の間のリレーションシップを決定するメソッドを呼び出すことができます。You can call the Equals method to determine whether two Single values are equal, or the CompareTo method to determine the relationship between two values.

    この Single 構造体は、比較演算子の完全なセットもサポートしています。The Single structure also supports a complete set of comparison operators. たとえば、等値または非等値をテストしたり、一方の値がもう一方の値以上かどうかを調べたりすることができます。For example, you can test for equality or inequality, or determine whether one value is greater than or equal to another value. オペランドの1つがの場合、 Double 比較を Single 実行する前に値がに変換され Double ます。If one of the operands is a Double, the Single value is converted to a Double before performing the comparison. オペランドの1つが整数型の場合は、比較を実行する前にに変換され Single ます。If one of the operands is an integral type, it is converted to a Single before performing the comparison. これらは拡大変換ですが、精度が失われる可能性があります。Although these are widening conversions, they may involve a loss of precision.

    警告

    精度の違いにより、等しいと予想される2つの値が等しくないと見なされる Single ことがあります。これは、比較の結果に影響します。Because of differences in precision, two Single values that you expect to be equal may turn out to be unequal, which affects the result of the comparison. 2つの値の比較の詳細については、「 等値のテスト 」を参照してください SingleSee the Testing for equality section for more information about comparing two Single values.

    また、、、 IsNaN 、およびの各メソッドを呼び出して、 IsInfinity IsPositiveInfinity IsNegativeInfinity これらの特殊な値をテストすることもできます。You can also call the IsNaN, IsInfinity, IsPositiveInfinity, and IsNegativeInfinity methods to test for these special values.

  • 算術演算Mathematical operations. 加算、減算、乗算、除算などの一般的な算術演算は、言語コンパイラと、メソッドではなく、共通中間言語 (CIL) 命令によって実装され Single ます。Common arithmetic operations such as addition, subtraction, multiplication, and division are implemented by language compilers and Common Intermediate Language (CIL) instructions rather than by Single methods. 算術演算のもう一方のオペランドがである場合、は Double Single 演算を実行する前にに変換され、 Double 演算の結果も値になり Double ます。If the other operand in a mathematical operation is a Double, the Single is converted to a Double before performing the operation, and the result of the operation is also a Double value. もう一方のオペランドが整数型である場合は、演算を実行する前にに変換され、 Single 演算の結果も値になり Single ます。If the other operand is an integral type, it is converted to a Single before performing the operation, and the result of the operation is also a Single value.

    staticクラスで (Visual Basic) メソッドを呼び出すことによって、他の数値演算を実行でき Shared System.Math ます。You can perform other mathematical operations by calling static (Shared in Visual Basic) methods in the System.Math class. これには、算術演算 (、 Math.Abs Math.Sign 、など Math.Sqrt )、geometry (やなど)、 Math.Cos Math.Sin および微積分 (など Math.Log ) で一般的に使用される追加のメソッドが含まれます。These include additional methods commonly used for arithmetic (such as Math.Abs, Math.Sign, and Math.Sqrt), geometry (such as Math.Cos and Math.Sin), and calculus (such as Math.Log). いずれの場合も、 Single 値はに変換され Double ます。In all cases, the Single value is converted to a Double.

    また、値内の個々のビットを操作することもでき Single ます。You can also manipulate the individual bits in a Single value. メソッドは、 BitConverter.GetBytes(Single) バイト配列でそのビットパターンを返します。The BitConverter.GetBytes(Single) method returns its bit pattern in a byte array. そのバイト配列をメソッドに渡すことによって BitConverter.ToInt32Single 値のビットパターンを32ビット整数で保持することもできます。By passing that byte array to the BitConverter.ToInt32 method, you can also preserve the Single value's bit pattern in a 32-bit integer.

  • 丸めRounding. 丸めは、浮動小数点表現と精度の問題によって生じる値の違いを減らすための手法としてよく使用されます。Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. 値は、 Single メソッドを呼び出すことによって丸めることができ Math.Round ます。You can round a Single value by calling the Math.Round method. ただし、 Single メソッドが呼び出される前に値がに変換され、変換に精度が失われる可能性があることに注意して Double ください。However, note that the Single value is converted to a Double before the method is called, and the conversion can involve a loss of precision.

  • 書式設定Formatting. Single値を文字列形式に変換するには、メソッドを呼び出す ToString か、または複合書式指定機能を使用します。You can convert a Single value to its string representation by calling the ToString method or by using the composite formatting feature. 書式指定文字列による浮動小数点値の文字列形式の制御方法の詳細については、「 標準の数値書式指定文字列 」および「 カスタム数値書式指定文字列 」を参照してください。For information about how format strings control the string representation of floating-point values, see the Standard Numeric Format Strings and Custom Numeric Format Strings topics.

  • 文字列を解析しています。Parsing strings. またはメソッドを呼び出して、浮動小数点値の文字列形式を値に変換でき Single Parse TryParse ます。You can convert the string representation of a floating-point value to a Single value by calling the Parse or TryParse method. 解析操作が失敗した場合、メソッドは Parse 例外をスローし TryParse ますが、メソッドはを返し false ます。If the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

  • 型変換Type conversion. Single構造体は、 IConvertible 任意の2つの標準 .NET Framework データ型間の変換をサポートするインターフェイスの明示的なインターフェイスの実装を提供します。The Single structure provides an explicit interface implementation for the IConvertible interface, which supports conversion between any two standard .NET Framework data types. 言語コンパイラでは、を値に変換する以外に、他のすべての標準数値型の値の暗黙的な変換もサポートされて Double Single います。Language compilers also support the implicit conversion of values for all other standard numeric types except for the conversion of Double to Single values. 以外の標準数値型の値から a への変換 Double Single は拡大変換であり、キャスト演算子または変換メソッドを使用する必要はありません。Conversion of a value of any standard numeric type other than a Double to a Single is a widening conversion and does not require the use of a casting operator or conversion method.

    ただし、32ビットと64ビットの整数値を変換すると、精度が失われる可能性があります。However, conversion of 32-bit and 64-bit integer values can involve a loss of precision. 次の表は、32ビット、64ビット、および型の有効桁数の違いを示してい Double ます。The following table lists the differences in precision for 32-bit, 64-bit, and Double types:

    種類Type 最大有効桁数 (10 進数)Maximum precision (in decimal digits) 内部精度 (10 進数)Internal precision (in decimal digits)
    Double 1515 1717
    Int32 および UInt32Int32 and UInt32 1010 1010
    Int64 および UInt64Int64 and UInt64 1919 1919
    Single 77 99

    精度の問題は、 Single 値に変換される値に最も頻繁に影響を及ぼし Double ます。The problem of precision most frequently affects Single values that are converted to Double values. 次の例では、同じ除算演算によって生成される2つの値が等しくありません。値の1つがに変換される単精度浮動小数点値であるため Double です。In the following example, two values produced by identical division operations are unequal, because one of the values is a single-precision floating point value that is converted to a 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 値を表します。Represents the smallest positive Single value that is greater than zero. このフィールドは定数です。This field is constant.

MaxValue

Single の最大有効値を表します。Represents the largest possible value of Single. このフィールドは定数です。This field is constant.

MinValue

Single の最小有効値を表します。Represents the smallest possible value of Single. このフィールドは定数です。This field is constant.

NaN

非数 (NaN) を表します。Represents not a number (NaN). このフィールドは定数です。This field is constant.

NegativeInfinity

負の無限大を表します。Represents negative infinity. このフィールドは定数です。This field is constant.

PositiveInfinity

正の無限大を表します。Represents positive infinity. このフィールドは定数です。This field is constant.

メソッド

CompareTo(Object)

このインスタンスと指定したオブジェクトを比較し、このインスタンスの値が指定したオブジェクトの値よりも小さいか、同じか、または大きいかを示す整数を返します。Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Single)

このインスタンスと指定した単精度浮動小数点数を比較し、このインスタンスの値が指定した単精度浮動小数点数の値よりも小さいか、同じか、それとも大きいかを示す整数を返します。Compares this instance to a specified single-precision floating-point number and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified single-precision floating-point number.

Equals(Object)

このインスタンスが指定されたオブジェクトに等しいかどうかを示す値を返します。Returns a value indicating whether this instance is equal to a specified object.

Equals(Single)

このインスタンスと指定した Single オブジェクトが同じ値を表しているかどうかを示す値を返します。Returns a value indicating whether this instance and a specified Single object represent the same value.

GetHashCode()

このインスタンスのハッシュ コードを返します。Returns the hash code for this instance.

GetTypeCode()

Single 値型の TypeCode を返します。Returns the TypeCode for value type Single.

IsFinite(Single)

指定した値が有限 (ゼロ、非正規、または正規) かどうかを判断します。Determines whether the specified value is finite (zero, subnormal or normal).

IsInfinity(Single)

指定した数値が負または正の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to negative or positive infinity.

IsNaN(Single)

指定した値が非数値 (NaN) かどうかを示す値を返します。Returns a value that indicates whether the specified value is not a number (NaN).

IsNegative(Single)

指定した値が負かどうかを判断します。Determines whether the specified value is negative.

IsNegativeInfinity(Single)

指定した数値が負の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to negative infinity.

IsNormal(Single)

指定した値が正規かどうかを判断します。Determines whether the specified value is normal.

IsPositiveInfinity(Single)

指定した数値が正の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to positive infinity.

IsSubnormal(Single)

指定した値が非正規かどうかを判断します。Determines whether the specified value is subnormal.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

指定したスタイルおよびカルチャに固有の書式による数値の文字列表現を含む文字スパンを、それと等価な単精度浮動小数点数に変換します。Converts a character span that contains the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

Parse(String)

数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number to its single-precision floating-point number equivalent.

Parse(String, IFormatProvider)

指定したカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified culture-specific format to its single-precision floating-point number equivalent.

Parse(String, NumberStyles)

指定したスタイルでの数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified style to its single-precision floating-point number equivalent.

Parse(String, NumberStyles, IFormatProvider)

指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

ToString()

このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation.

ToString(IFormatProvider)

このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString(String)

指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation, using the specified format.

ToString(String, IFormatProvider)

このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

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

現在の浮動小数点数インスタンスの値の、指定した文字スパンへの書式設定を試みます。Tries to format the value of the current float number instance into the provided span of characters.

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

指定したスタイルおよびカルチャに固有の書式による数値のスパン表現を、それと等価な単精度浮動小数点数に変換します。Converts the span representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. 戻り値は変換が成功したか失敗したかを示します。A return value indicates whether the conversion succeeded or failed.

TryParse(ReadOnlySpan<Char>, Single)

文字スパン内の数値の文字列表現を、それと等価の単精度浮動小数点数に変換します。Converts the string representation of a number in a character span to its single-precision floating-point number equivalent. 戻り値は変換が成功したか失敗したかを示します。A return value indicates whether the conversion succeeded or failed.

TryParse(String, NumberStyles, IFormatProvider, Single)

指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. 戻り値は変換が成功したか失敗したかを示します。A return value indicates whether the conversion succeeded or failed.

TryParse(String, Single)

数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number to its single-precision floating-point number equivalent. 戻り値は変換が成功したか失敗したかを示します。A return value indicates whether the conversion succeeded or failed.

演算子

Equality(Single, Single)

指定した 2 つの Single 値が等しいかどうかを示す値を返します。Returns a value that indicates whether two specified Single values are equal.

GreaterThan(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値より大きいかどうかを示す値を返します。Returns a value that indicates whether a specified Single value is greater than another specified Single value.

GreaterThanOrEqual(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値以上かどうかを示す値を返します。Returns a value that indicates whether a specified Single value is greater than or equal to another specified Single value.

Inequality(Single, Single)

指定した 2 つの Single 値が等しくないかどうかを示す値を返します。Returns a value that indicates whether two specified Single values are not equal.

LessThan(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値より小さいかどうかを示す値を返します。Returns a value that indicates whether a specified Single value is less than another specified Single value.

LessThanOrEqual(Single, Single)

指定した Single 値が、指定したもう 1 つの Single 値以下かどうかを示す値を返します。Returns a value that indicates whether a specified Single value is less than or equal to another specified Single value.

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

IComparable.CompareTo(Object)

現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスの並べ替え順序での位置が、比較対象のオブジェクトと比べて前か、後か、または同じかを示す整数を返します。Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

IConvertible.GetTypeCode()

インスタンスの TypeCode を返します。Returns the TypeCode for this instance.

IConvertible.ToBoolean(IFormatProvider)

このメンバーの詳細については、「ToBoolean(IFormatProvider)」をご覧ください。For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

このメンバーの詳細については、「ToByte(IFormatProvider)」をご覧ください。For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

この変換はサポートされていません。This conversion is not supported. このメソッドを使用しようとすると、InvalidCastException がスローされます。Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

この変換はサポートされていません。This conversion is not supported. このメソッドを使用しようとすると、InvalidCastException がスローされます。Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

このメンバーの詳細については、「ToDecimal(IFormatProvider)」をご覧ください。For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

このメンバーの詳細については、「ToDouble(IFormatProvider)」をご覧ください。For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

このメンバーの詳細については、「ToInt16(IFormatProvider)」をご覧ください。For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

このメンバーの詳細については、「ToInt32(IFormatProvider)」をご覧ください。For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

このメンバーの詳細については、「ToInt64(IFormatProvider)」をご覧ください。For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

このメンバーの詳細については、「ToSByte(IFormatProvider)」をご覧ください。For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

このメンバーの詳細については、「ToSingle(IFormatProvider)」をご覧ください。For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

このメンバーの詳細については、「ToType(Type, IFormatProvider)」をご覧ください。For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

このメンバーの詳細については、「ToUInt16(IFormatProvider)」をご覧ください。For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

このメンバーの詳細については、「ToUInt32(IFormatProvider)」をご覧ください。For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

このメンバーの詳細については、「ToUInt64(IFormatProvider)」をご覧ください。For a description of this member, see ToUInt64(IFormatProvider).

適用対象

スレッド セーフ

この型のすべてのメンバーは、スレッドセーフです。All members of this type are thread safe. インスタンスの状態を変更するように見えるメンバーは、実際には新しい値で初期化された新しいインスタンスを返します。Members that appear to modify instance state actually return a new instance initialized with the new value. 他の型と同様に、この型のインスタンスを含む共有変数の読み取りと書き込みは、スレッドセーフを保証するためにロックによって保護される必要があります。As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

こちらもご覧ください