Single Single Single Single Struct

定義

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

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

注釈

Single型は、負の 3.402823 e38 から正の 3.402823 e38 までの値を持ち、正または負の0、 PositiveInfinityNegativeInfinity、(NaN) ではない値を持つ単精度32ビットの数値を表します。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. この不均衡は、"R"標準の数値書式指定文字列を使用して2つSingle Singleの値を表示した場合にのみわかります。これは、必要に応じて、型でサポートされている9桁すべての有効桁数を表示します。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. Single値には最大7桁の有効桁数がありますが、内部的には最大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)ステートメント内の書式項目をおよび{1}から{0}{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. 次の例では、 Single 3 つの値が文字列に変換され、ファイルに保存されます。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
    

    この場合、次の例に示すように、値のSingle完全な有効桁数を保持するために "G9" 標準の数値書式指定文字列を使用すると、値が正常にラウンドトリップされることがあります。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. 多くの場合、一見同等DoubleSingle値に変換される値は、精度が異なるため、値と等しくありません。DoubleA Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. 次の例では、同じ除算演算の結果がDoubleSingleと値に割り当てられています。In the following example, the result of identical division operations is assigned to a Double value and a Single value. 値がにキャストされた後、2つの値の比較によって等しくないことが示されます。Double SingleAfter 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

等しいと見なされるためにSingleは、2つの値が同一の値を表す必要があります。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. 結果として、2つEqualsの値が等しいかどうかを判断するためにメソッドCompareToを呼び出し、2つ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. 次の例では、最初の値の有効桁数Singleが7桁で、2番目の値が9であるため、2つの一見等しい値が等しくないことがわかります。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. 次の例では、 Single 1 つの値が二乗で、平方根が計算され、元の値が復元されます。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:

  • 2つMath.Roundの値の有効桁数が同じであることを確認するには、メソッドを呼び出します。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は、等しいかどうかをテストするときに 2 Singleつの値の間の距離の絶対測定値として使用されることがあります。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.MaxValuePositiveInfinityオーバーフローする操作の結果と、オーバーフロー 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による除算のその他のケースではPositiveInfinityNegativeInfinityまたはのいずれかになります。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.NaNである引数を持つすべての操作。Any 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. Decimal29桁の有効桁数をサポートします。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. Int3210進数の有効桁数をサポートします。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. UInt3210進数の有効桁数をサポートします。Singleは9をサポートします。UInt32 supports 10 decimal digits of precision; Single supports 9.
UInt64 WideningWidening はい。Yes. Int6420桁の有効桁数をサポートします。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 Single.NegativeInfinity Single.NaN Single.PositiveInfinityの各Double.PositiveInfinity値は、それぞれ、、およびにDouble.NegativeInfinity変換されます。In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity covert 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に、、、 Int32UInt32 Int64、、およびUInt64の値Doubleを値に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値C#からDouble以外のプリミティブ数値データ型の値への変換は縮小変換であり、キャスト演算子 (では) または変換メソッド (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 Checked コンテキストで変換が発生した場合の例外。OverflowExceptionAn OverflowException exception if the conversion occurs in a checked context.

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

またSingle.NaN Single.NegativeInfinity OverflowException 、、、およびは、checked コンテキストで整数への変換のためにをスローしますが、これらの値は unchecked コンテキストで整数に変換されるとオーバーフローします。 Single.PositiveInfinityIn 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.NaNDouble.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キーワードによって) で行われます。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# checkedステートメントをコメントアウトすることで、Visual Basic の unchecked コンテキストで変換を実行できます。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.

    警告

    精度の違いにより、等しいSingleと予想される2つの値が等しくないと見なされることがあります。これは、比較の結果に影響します。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つSingleの値の比較の詳細については、「等値のテスト」を参照してください。See the Testing for equality section for more information about comparing two Single values.

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

  • 算術演算Mathematical operations. 加算、減算、乗算、除算などの一般的な算術演算は、言語コンパイラと、メソッドでSingleはなく、共通中間言語 (CIL) 命令によって実装されます。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 Shared Visual Basic) メソッドを呼び出すことによって、他の数値演算を実行できます。 System.MathYou 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.CosMath.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.ToInt32メソッドに渡すことによって、 Single値のビットパターンを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. 値はSingleMath.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. ParseまたSingleTryParseメソッドを呼び出して、浮動小数点値の文字列形式を値に変換できます。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体は、任意の2つのIConvertible標準 .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. 以外Doubleの標準数値型の値から a 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つの値が等しくありDoubleません。値の1つがに変換される単精度浮動小数点値であるためです。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 Epsilon Epsilon Epsilon

ゼロより大きい最小の Single 値を表します。Represents the smallest positive Single value that is greater than zero. このフィールドは定数です。This field is constant.

MaxValue MaxValue MaxValue MaxValue

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

MinValue MinValue MinValue MinValue

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

NaN NaN NaN NaN

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

NegativeInfinity NegativeInfinity NegativeInfinity NegativeInfinity

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

PositiveInfinity PositiveInfinity PositiveInfinity PositiveInfinity

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

メソッド

CompareTo(Object) CompareTo(Object) CompareTo(Object) 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) CompareTo(Single) CompareTo(Single) 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) Equals(Object) Equals(Object) Equals(Object)

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

Equals(Single) Equals(Single) Equals(Single) Equals(Single)

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

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

IsFinite(Single) IsFinite(Single) IsFinite(Single) IsFinite(Single)

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

IsInfinity(Single) IsInfinity(Single) IsInfinity(Single) IsInfinity(Single)

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

IsNaN(Single) IsNaN(Single) IsNaN(Single) IsNaN(Single)

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

IsNegative(Single) IsNegative(Single) IsNegative(Single) IsNegative(Single)

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

IsNegativeInfinity(Single) IsNegativeInfinity(Single) IsNegativeInfinity(Single) IsNegativeInfinity(Single)

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

IsNormal(Single) IsNormal(Single) IsNormal(Single) IsNormal(Single)

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

IsPositiveInfinity(Single) IsPositiveInfinity(Single) IsPositiveInfinity(Single) IsPositiveInfinity(Single)

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

IsSubnormal(Single) IsSubnormal(Single) IsSubnormal(Single) IsSubnormal(Single)

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

Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) 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.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) 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(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String) Parse(String) Parse(String) Parse(String)

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

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

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

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

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

ToString(String) ToString(String) ToString(String) ToString(String)

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

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

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

ToString() ToString() ToString() ToString()

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

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)
TryParse(String, Single) TryParse(String, Single) TryParse(String, Single) 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.

TryParse(ReadOnlySpan<Char>, Single) TryParse(ReadOnlySpan<Char>, Single) TryParse(ReadOnlySpan<Char>, Single) TryParse(ReadOnlySpan<Char>, Single)
TryParse(String, NumberStyles, IFormatProvider, Single) TryParse(String, NumberStyles, IFormatProvider, Single) TryParse(String, NumberStyles, IFormatProvider, Single) 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.

演算子

Equality(Single, Single) Equality(Single, Single) Equality(Single, Single) Equality(Single, Single)

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

GreaterThan(Single, Single) GreaterThan(Single, Single) GreaterThan(Single, Single) 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) GreaterThanOrEqual(Single, Single) GreaterThanOrEqual(Single, Single) 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) Inequality(Single, Single) Inequality(Single, Single) Inequality(Single, Single)

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

LessThan(Single, Single) LessThan(Single, Single) LessThan(Single, Single) 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) LessThanOrEqual(Single, Single) LessThanOrEqual(Single, Single) 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) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

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

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

このメンバーの説明については、ToByte(IFormatProvider) のトピックを参照してください。For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

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

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

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

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

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

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

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

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

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

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

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

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

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

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

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

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

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

IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

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

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

このメンバーの説明については、ToUInt16(IFormatProvider) のトピックを参照してください。For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

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

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(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.

こちらもご覧ください