この記事は機械翻訳されています。英語版の記事を表示するには、[英語] のチェック ボックスをオンにしてください。また、テキストにマウス ポインターを合わせると、ポップアップ ウィンドウに英語のテキストを表示することもできます。
翻訳
英語

Single 構造体

 

公開日: 2016年10月

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

名前空間:   System
アセンブリ:  mscorlib (mscorlib.dll 内)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Single : IComparable, IFormattable, IConvertible, 
	IComparable<float>, IEquatable<float>

名前説明
System_CAPS_pubmethodCompareTo(Object)

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

System_CAPS_pubmethodCompareTo(Single)

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

System_CAPS_pubmethodEquals(Object)

対象のインスタンスが、指定したオブジェクトに等しいかどうかを示す値を返します。(ValueType.Equals(Object) をオーバーライドします。)

System_CAPS_pubmethodEquals(Single)

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

System_CAPS_pubmethodGetHashCode()

このインスタンスのハッシュ コードを返します。(ValueType.GetHashCode() をオーバーライドします。)

System_CAPS_pubmethodGetType()

現在のインスタンスの Type を取得します。(Object から継承されます。)

System_CAPS_pubmethodGetTypeCode()

TypeCode 値型の Single を返します。

System_CAPS_pubmethodSystem_CAPS_staticIsInfinity(Single)

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

System_CAPS_pubmethodSystem_CAPS_staticIsNaN(Single)

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

System_CAPS_pubmethodSystem_CAPS_staticIsNegativeInfinity(Single)

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

System_CAPS_pubmethodSystem_CAPS_staticIsPositiveInfinity(Single)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

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

System_CAPS_pubmethodToString()

このインスタンスの数値を、それと等価な文字列形式に変換します。(ValueType.ToString() をオーバーライドします。)

System_CAPS_pubmethodToString(IFormatProvider)

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

System_CAPS_pubmethodToString(String)

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

System_CAPS_pubmethodToString(String, IFormatProvider)

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

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Single)

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

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Single)

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

名前説明
System_CAPS_pubfieldSystem_CAPS_staticEpsilon

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

System_CAPS_pubfieldSystem_CAPS_staticMaxValue

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

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

System_CAPS_pubfieldSystem_CAPS_staticNaN

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

System_CAPS_pubfieldSystem_CAPS_staticNegativeInfinity

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

System_CAPS_pubfieldSystem_CAPS_staticPositiveInfinity

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

名前説明
System_CAPS_puboperatorSystem_CAPS_staticEquality(Single, Single)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Single, Single)

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

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Single, Single)

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

System_CAPS_puboperatorSystem_CAPS_staticInequality(Single, Single)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Single, Single)

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

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Single, Single)

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

名前説明
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToBoolean」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToByte」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToDecimal」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToDouble」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToInt16」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToInt32」をご覧ください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToInt64」をご覧ください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToSByte」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToSingle」をご覧ください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの説明については、「IConvertible.ToType」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToUInt16」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToUInt32」をご覧ください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

この API は 製品 インフラストラクチャをサポートします。コードから直接使用するためのものではありません。 このメンバーの詳細については、「IConvertible.ToUInt64」をご覧ください。

Single 値型は、正または負のゼロと同様に正の 3.402823 e 38 ~-3.402823e38 から範囲の値を単精度 32 ビット数を表します PositiveInfinity, 、NegativeInfinity, 、および非数 (NaN)。 値 (惑星または銀河系間の距離) などの大きい、または (に物質の分子質量) などの非常に小さなと多くの場合ではない (地球から別の太陽系までの距離) などの正確な値を表すものでは。 Single 型が、IEC 60559: 1989 (IEEE 754) バイナリ浮動小数点演算の標準に準拠しています。

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

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

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

パーツ

ビット

有効桁または仮数部

0-22

指数

23-30

記号 (0 = 1、正の数値 = 負の値)

31

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

using System;

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

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

いくつかの数字は、小数部のバイナリ値として正確に表すことができない、ため浮動小数点数には実際の数値およそことができます。

すべての浮動小数点数も浮動小数点値が実数を概算する方法を決定する限られた数の有効桁数があります。 A Single 最大 9 桁が内部的に保持されて、値が最大 7 桁の有効桁数、します。 これは、浮動小数点演算の精度浮動小数点値を変更することがありますがないことを意味します。 次の例は、大規模な単精度浮動小数点値を定義しの製品を追加 Single.Epsilon と 1,000兆にします。 ただし、製品は、元の浮動小数点値を変更するには小さすぎます。 最下位の桁は 1/10、1/100、1/1000、製品内の最上位の添字は 1-312します。

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123456789e4f;
      Single additional = Single.Epsilon * 1e12f;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    1.234568E+12 + 1.401298E-33 = 1.234568E+12

浮動小数点数の制限された有効桁数には、いくつかのような影響があります。

  • 特定の有効桁数で等しく見える 2 つの浮動小数点数は有効桁数が異なると同じにする場合があります比較されません。 次の例では、一連の数字を加算し、その合計がその期待される合計と比較します。 2 つの値は同じであるへの呼び出しに見えますが、 Equals メソッドであることを示します。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0:R}) does not equal the total ({1:R}).",
                               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).   
    

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

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

    小数部の値を持つ数値演算の精度が重要なを使用して、 Decimal 型の代わりに、 Single 型です。 時の範囲外の整数の値を持つ数値演算の精度、 Int64 または UInt64 使用の種類は重要では、 BigInteger 型です。

  • 値には、浮動小数点数が含まれている場合リップに失敗の可能性があります。 値は、操作を元の浮動小数点数を別の形式に変換すると逆の操作が浮動小数点数に変換されたフォームを変換し、最終的な浮動小数点数が元の浮動小数点数と等しい場合に、ラウンドト リップさせると言われます。 ラウンド トリップは、1 つまたは複数の最下位の桁が失われたか、変換で変更されたために失敗する可能性があります。 次の例では、次の 3 つ Single 値が文字列に変換され、ファイルに保存します。 出力を値と同一であるように見えますが、復元された値は元の値と同じではありません。

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 <> 2.882883
    //       0.3333333 <> 0.3333333
    //       3.141593 <> 3.141593
    

    この場合、値を指定できますが正常に往復"R"を使用して、 標準数値書式指定文字列 の最大精度を保持するために Single 値は、次の例のようにです。

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{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
    
  • Single 値があるよりも精度が低い Double 値。 A Single 一見同等に変換される値 Double 多くの場合と等しくない、 Double 値の精度が異なるのためです。 次の例では、同一の除算演算の結果が割り当てられている、 Double 値と Single 値。 後に、 Single にキャストされた値、 Double, 、2 つの値の比較は、それらが等しくないことを示しています。

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

    この問題を避けるためには、使用するか、 Double データの型の代わりに、 Single データ型、または使用する、 Round メソッドの両方の値が同一の有効桁数を含めるようにします。

同等と見なされるに 2 つ Single 値が同一の値を表す必要があります。 ただし、有効桁数に値の間の違いにより、または 1 つまたは両方の値によって精度が失われるのためには、多くの場合と同じであると想定される浮動小数点値に有効桁数の違いによりに等しくない場合します。 その結果、するために呼び出す、 Equals 呼び出しまたは 2 つの値が等しいかどうかを決定する方法、 CompareTo 2 つの間の関係を決定する方法 Single の値が多くの場合、予期しない結果を生成します。 明らかに等しい 2 つ、これは次の例で示した Single 値が等しくない場合、最初の値が 2 番目の値は 9、7 桁の精度を持つために手数です。

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

等しくない場合に異なるコード パスをたどることと、多くの場合、さまざまな方法で処理される、計算値を証明します。 次の例では、1 つ Single 値を 2 乗し、元の値を復元する平方根を計算し、します。 1 秒あたり Single は 3.51 が乗算され、前に、結果の平方根が元の値を復元する 3.51 で割った値を二乗します。 同じように見えますが 2 つの値への呼び出し、 Equals(Single) メソッドでは、それらが等しくないことを示します。 "R"標準書式指定文字列を使用して、それぞれの有効桁数がすべて表示される結果の文字列を取得する Single 値は 2 番目の値があること.0000000000001 最初よりも小さいです。

using System;

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

精度の損失が比較の結果に影響する可能性が高い場合は、呼び出す代わりに、次の手法を使用できる、 Equals または CompareTo メソッド。

  • 呼び出す、 Math.Round 両方の値が同一の有効桁数を含めることを確認します。 次の例では、2 つの小数部の値が等しいように、このアプローチを使用する前の例を変更します。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = .3333333f;
          float value2 = 1.0f/3;
          int precision = 7;
          value1 = (float) Math.Round(value1, precision);
          value2 = (float) Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    

    精度の問題が中間値の丸め処理に適用されることに注意してください。 詳細については、Math.Round(Double, Int32, MidpointRounding) メソッドを参照してください。

  • 等値ではなく概数に等しいかどうかをテストします。 この手法では、どちらか絶対パスを定義することが必要です量の 2 つの値は異なるが、それでもする、指定した、または、小さい方の値が大きい方の値から分岐できます相対的な時間を定義します。

    System_CAPS_warning警告

    Single.Epsilon 2 つの間の距離の絶対的な測定値として使用される場合があります Single 値は等しいかどうかをテストする場合。 ただし、 Single.Epsilon または、追加、削除、最小有効値を測定、 Single 値が 0 です。 ほとんどの正の数および負 Single 値、値の Single.Epsilon が小さすぎてを検出します。 そのため、ゼロ値を除くしないでの等価テストで使用します。

    次の例では、後者のアプローチを使用して、定義、 IsApproximatelyEqual 2 つの値の間の相対的な差異をテストするメソッドです。 呼び出しの結果も対比させて、 IsApproximatelyEqual メソッドおよび Equals(Single) メソッドです。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1f;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001f));   
       }
    
       static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
    
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 1.00000012: False
    //       1 is approximately equal to 1.00000012: True
    

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

  • 浮動小数点演算の結果が小さすぎるため、変換先の形式の場合は、結果は 0 です。 これは、次の例のように、2 つの非常に小さい浮動小数点数値を乗算するときに発生します。

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
       }
    }
    // The example displays the following output:
    //       1.163287E-36 * 9.164234E-25 = 0
    //       0 = 0: True
    
  • 浮動小数点演算の結果の大きさが変換先の形式の範囲を超えている場合、操作の結果は PositiveInfinity または NegativeInfinity, ] の結果の符号をクリックします。 オーバーフローが発生する操作の結果 Single.MaxValuePositiveInfinity, 、およびオーバーフローが発生する操作の結果 Single.MinValueNegativeInfinity, 次の例を示します。

    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
    

    PositiveInfinity 正の被除数と 0 による除算によっても発生し、 NegativeInfinity 被除数を負の値に 0 による除算の結果します。

  • 浮動小数点演算が有効でない場合、操作の結果は NaNです。 たとえば、 NaN 、次の操作に起因します。

    • 0 の被除数とゼロによる除算。 いずれかで結果がゼロで除算の他のケースに注意してください PositiveInfinity または NegativeInfinityです。

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

    • 値が引数を操作 Single.NaNします。

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

次の表は、他のプリミティブ数値型の値の発生しうる変換、 Single 値も表示するかどうかと、変換を拡大または縮小するかどうか、その結果 Single 元の値よりも精度が低い場合があります。

変換 (

拡大縮小

有効桁数が失われる可能性

Byte

Widening

いいえ

Decimal

Widening

C# が必要であるキャスト演算子に注意してください。

はい。 Decimal 29 桁の小数点精度; をサポートしています Single 9 をサポートしています。

Double

縮小変換です。範囲外の値に変換する Double.NegativeInfinity または Double.PositiveInfinityです。

はい。 Double 17 桁の小数点精度; をサポートしています Single 9 をサポートしています。

Int16

Widening

いいえ

Int32

Widening

はい。 Int32 10 桁の小数点精度; をサポートしています Single 9 をサポートしています。

Int64

Widening

はい。 Int64 19 桁の小数点精度; をサポートしています Single 9 をサポートしています。

SByte

Widening

いいえ

UInt16

Widening

いいえ

UInt32

Widening

はい。 UInt32 10 桁の小数点精度; をサポートしています Single 9 をサポートしています。

UInt64

Widening

はい。 Int64 20 桁の有効桁数、小数点をサポートしています Single 9 をサポートしています。

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

using System;

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

さらに、 DoubleDouble.NaN, 、Double.PositiveInfinity, 、および Double.NegativeInfinity に変換 Single.NaN, 、Single.PositiveInfinity, 、および Single.NegativeInfinity, 、それぞれします。

注意するいくつかの数値型の値の変換、 Single 値は、有効桁数の損失を伴うことができます。 精度の損失を変換する場合は可能な例に示すように Decimal, 、Double, 、Int32, 、Int64, 、UInt32, 、および UInt64Single 値。

変換、 Single 値を Double 拡大変換されます。 変換で精度が失われる場合可能性、 Double 型のため正確に表現していない、 Single 値。

変換、 Single 以外の任意のプリミティブ数値データ型の値に値を Double 縮小変換は、キャスト演算子 (C# の場合) または (Visual Basic) で変換メソッドが必要です。 対象の種類が定義されている値が対象のデータ型の範囲を超える MinValueMaxValue プロパティの動作は次の表に示すようにします。

ターゲットの種類

結果

任意の整数型

OverflowException Checked コンテキストで変換が行われる場合に例外です。

Unchecked コンテキスト (c# では既定値) に変換する場合は、変換操作が成功したが、値がオーバーフローが発生します。

Decimal

OverflowException 例外

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

変換が精度の損失が考えられますことに注意してください、 Single 値を別の数値型にします。 整数以外の変換の場合 Double 値、例の出力に示すように、小数が失われるときに、 Single 値が (Visual Basic の場合) のように丸められますか (と同様に C# の場合) に切り捨てられます。 変換 DecimalSingle 値、 Double 値では、対象のデータ型、正確に表現できません。

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

using System;

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

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

数値型の変換の詳細については、次を参照してください。 .NET Framework における型変換.NET Framework における型変換の表です。

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

  • の値の比較します。 呼び出すことができます、 Equals 2 つあるかどうかを決定する方法 Single 値が等しいか、または CompareTo メソッドを 2 つの値の間の関係を決定します。

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

    System_CAPS_warning警告

    有効桁数、相違のため 2 つ Single と等しくなるはずの値に手数に等しくない場合、比較の結果に影響を与えます。 参照してください、 等価性テスト 2 つの比較についての詳細については Single 値。

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

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

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

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

  • 丸めします。 丸め処理はよく使用手法として浮動小数点表現と精度の問題によって発生する値の相違点の影響を軽減します。 丸めることができます、 Single を呼び出して値、 Math.Round メソッドです。 ただし、 Single に変換される値、 Double 前に、メソッドが呼び出され、変換は、有効桁数の損失を伴うことができます。

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

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

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

    ただし、32 ビットおよび 64 ビットの整数値の変換では、精度が失われるをすることができます。 次の表に、32 ビット、64 ビットの有効桁数の違いと Double の種類。

    Type

    最大有効桁数 (10 進数字) に

    (10 進数字) に内部の有効桁数

    Double

    15

    17

    Int32 および UInt32

    10

    10

    Int64 および UInt64

    19

    19

    Single

    7

    9

    精度の問題に最も頻繁に影響を与えます Single 値に変換される Double 値。 次の例では、同一の除算演算によって生成される 2 つの値が等しくない、値のいずれかに変換する単精度浮動小数点値であるため、 Doubleです。

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

ユニバーサル Windows プラットフォーム
8 以降で使用可能
.NET Framework
1.1 以降で使用可能
ポータブル クラス ライブラリ
サポート対象: 移植可能 .NET プラットフォーム
Silverlight
2.0 以降で使用可能
Windows Phone Silverlight
7.0 以降で使用可能
Windows Phone
8.1 以降で使用可能

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

トップに戻る
表示: