Single 構造体

定義

``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.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable``````
``public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable``
``````type single = struct
interface IConvertible
interface IFormattable``````
``````type single = struct
interface 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 までの値を持つ単精度32ビット数値を表します。また、正または負の0、PositiveInfinityNegativeInfinity、および非数 (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:

ExponentExponent 23-3023-30

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
``````

すべての浮動小数点数には、有効桁数が制限されています。これにより、浮動小数点値が実数を近似する精度も決まります。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;
}
}
// 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
End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456
``````

• 特定の有効桁数で等しく見える 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.

小数部の値を持つ数値演算の精度が重要な場合は、Single 型ではなく Decimal 型を使用します。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];
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 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];
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 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. 一見同等の Double に変換される Single 値は、精度が異なるため Double 値と等しくないことがよくあります。A 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
``````

この問題を回避するには、Single データ型の代わりに Double データ型を使用するか、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

``````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
``````

``````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
``````

• 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.

次の例では、後者の方法を使用して、2つの値の相対的な差をテストする `IsApproximatelyEqual` メソッドを定義しています。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になります。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で正の被除数を除算した結果も得られます。また、0による除算の結果は負の被除数で NegativeInfinity ます。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.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.

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 は、10桁の有効桁数をサポートします。Single は9をサポートしています。Int64 supports 20 decimal digits of precision; Single supports 9.

``````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)
``````

In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity convert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

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

Decimal OverflowException の例外です。An OverflowException exception,

さらに、Single.NaNSingle.PositiveInfinity、および Single.NegativeInfinity は checked コンテキストで整数への変換のための 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.NaNDouble.PositiveInfinity、および Double.NegativeInfinityにそれぞれ変換されます。For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

``````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)
``````

浮動小数点機能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 値が等しいかどうかを判断したり、2つの値の間のリレーションシップを決定する CompareTo メソッドを呼び出したりできます。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. オペランドのいずれかが 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つの Single 値の比較の詳細については、「等値のテスト」を参照してください。See the Testing for equality section for more information about comparing two Single values.

IsNaNIsInfinityIsPositiveInfinity、および 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の場合、演算を実行する前に SingleDouble に変換され、操作の結果も 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.

System.Math クラスで `static` (Visual Basic で`Shared`) メソッドを呼び出すことによって、他の数値演算を実行できます。You can perform other mathematical operations by calling `static` (`Shared` in Visual Basic) methods in the System.Math class. これには、算術演算 (Math.AbsMath.SignMath.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 メソッドに渡すことによって、32ビット整数で Single 値のビットパターンを保持することもできます。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. Math.Round メソッドを呼び出すことによって、Single 値を丸めることができます。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. ToString メソッドを呼び出すか、または複合書式指定機能を使用して、Single 値を文字列形式に変換できます。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 または TryParse メソッドを呼び出すことによって、浮動小数点値の文字列形式を Single 値に変換できます。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つの標準 .NET Framework データ型間の変換をサポートする IConvertible インターフェイスの明示的なインターフェイスの実装を提供します。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 以外の標準数値型の値を 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

精度の問題は、Double 値に変換される Single 値に最も頻繁に影響します。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
``````

フィールド

 ゼロより大きい最小の Single 値を表します。Represents the smallest positive Single value that is greater than zero. このフィールドは定数です。This field is constant. Singleの最大有効値を表します。Represents the largest possible value of Single. このフィールドは定数です。This field is constant. Singleの最小有効値を表します。Represents the smallest possible value of Single. このフィールドは定数です。This field is constant. 非数 (`NaN`) を表します。Represents not a number (`NaN`). このフィールドは定数です。This field is constant. 負の無限大を表します。Represents negative infinity. このフィールドは定数です。This field is constant. 正の無限大を表します。Represents positive infinity. このフィールドは定数です。This field is constant.

メソッド

 このインスタンスと指定したオブジェクトを比較し、このインスタンスの値が指定したオブジェクトの値よりも小さいか、同じか、または大きいかを示す整数を返します。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. このインスタンスと指定した単精度浮動小数点数を比較し、このインスタンスの値が指定した単精度浮動小数点数の値よりも小さいか、同じか、それとも大きいかを示す整数を返します。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. このインスタンスが指定したオブジェクトと同一であるかどうかを示す値を返します。Returns a value indicating whether this instance is equal to a specified object. このインスタンスと指定した Single オブジェクトが同じ値を表しているかどうかを示す値を返します。Returns a value indicating whether this instance and a specified Single object represent the same value. このインスタンスのハッシュ コードを返します。Returns the hash code for this instance. TypeCode 値型の Singleを返します。Returns the TypeCode for value type Single. 指定した値が有限 (ゼロ、非正規、または正規) かどうかを判断します。Determines whether the specified value is finite (zero, subnormal or normal). 指定した数値が負または正の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to negative or positive infinity. 指定した値が非数値 (NaN) かどうかを示す値を返します。Returns a value that indicates whether the specified value is not a number (NaN). 指定した値が負かどうかを判断します。Determines whether the specified value is negative. 指定した数値が負の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to negative infinity. 指定した値が正規かどうかを判断します。Determines whether the specified value is normal. 指定した数値が正の無限大と評価されるかどうかを示す値を返します。Returns a value indicating whether the specified number evaluates to positive infinity. 指定した値が非正規かどうかを判断します。Determines whether the specified value is subnormal. 指定したスタイルおよびカルチャに固有の書式による数値の文字列表現を含む文字スパンを、それと等価な単精度浮動小数点数に変換します。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. 数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number to its single-precision floating-point number equivalent. 指定したカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified culture-specific format to its single-precision floating-point number equivalent. 指定したスタイルでの数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified style to its single-precision floating-point number equivalent. 指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation. このインスタンスの数値を、指定したカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information. 指定した書式を使用して、このインスタンスの数値を、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation, using the specified format. このインスタンスの数値を、指定した書式およびカルチャ固有の書式情報を使用して、それと等価な文字列形式に変換します。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information. 現在の浮動小数点数インスタンスの値の、指定した文字スパンへの書式設定を試みます。Tries to format the value of the current float number instance into the provided span of characters. 指定したスタイルおよびカルチャに固有の書式による数値のスパン表現を、それと等価な単精度浮動小数点数に変換します。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. 文字スパン内の数値の文字列表現を、それと等価の単精度浮動小数点数に変換します。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. 指定したスタイルおよびカルチャに固有の書式による数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。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. 数値の文字列形式を、それと等価な単精度浮動小数点数に変換します。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.

演算子

 指定した 2 つの Single 値が等しいかどうかを示す値を返します。Returns a value that indicates whether two specified Single values are equal. 指定した Single 値が、指定したもう 1 つの Single 値より大きいかどうかを示す値を返します。Returns a value that indicates whether a specified Single value is greater than another specified Single value. 指定した Single 値が、指定したもう 1 つの Single 値以上かどうかを示す値を返します。Returns a value that indicates whether a specified Single value is greater than or equal to another specified Single value. 指定した 2 つの Single 値が等しくないかどうかを示す値を返します。Returns a value that indicates whether two specified Single values are not equal. 指定した Single 値が、指定したもう 1 つの Single 値より小さいかどうかを示す値を返します。Returns a value that indicates whether a specified Single value is less than another specified Single value. 指定した Single 値が、指定したもう 1 つの Single 値以下かどうかを示す値を返します。Returns a value that indicates whether a specified Single value is less than or equal to another specified Single value.

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

 現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスの並べ替え順序での位置が、比較対象のオブジェクトと比べて前か、後か、または同じかを示す整数を返します。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. インスタンスの TypeCode を返します。Returns the TypeCode for this instance. このメンバーの説明については、ToBoolean(IFormatProvider) のトピックを参照してください。For a description of this member, see ToBoolean(IFormatProvider). このメンバーの説明については、ToByte(IFormatProvider) のトピックを参照してください。For a description of this member, see ToByte(IFormatProvider). この変換はサポートされていません。This conversion is not supported. このメソッドを使用しようとすると、InvalidCastException がスローされます。Attempting to use this method throws an InvalidCastException. この変換はサポートされていません。This conversion is not supported. このメソッドを使用しようとすると、InvalidCastException がスローされます。Attempting to use this method throws an InvalidCastException. このメンバーの説明については、ToDecimal(IFormatProvider) のトピックを参照してください。For a description of this member, see ToDecimal(IFormatProvider). このメンバーの説明については、ToDouble(IFormatProvider) のトピックを参照してください。For a description of this member, see ToDouble(IFormatProvider). このメンバーの説明については、ToInt16(IFormatProvider) のトピックを参照してください。For a description of this member, see ToInt16(IFormatProvider). このメンバーの説明については、ToInt32(IFormatProvider) のトピックを参照してください。For a description of this member, see ToInt32(IFormatProvider). このメンバーの説明については、ToInt64(IFormatProvider) のトピックを参照してください。For a description of this member, see ToInt64(IFormatProvider). このメンバーの説明については、ToSByte(IFormatProvider) のトピックを参照してください。For a description of this member, see ToSByte(IFormatProvider). このメンバーの説明については、ToSingle(IFormatProvider) のトピックを参照してください。For a description of this member, see ToSingle(IFormatProvider). このメンバーの説明については、ToType(Type, IFormatProvider) のトピックを参照してください。For a description of this member, see ToType(Type, IFormatProvider). このメンバーの説明については、ToUInt16(IFormatProvider) のトピックを参照してください。For a description of this member, see ToUInt16(IFormatProvider). このメンバーの説明については、ToUInt32(IFormatProvider) のトピックを参照してください。For a description of this member, see ToUInt32(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.