FloatingPoint

Overview 概要

Floating-point types are used to represent fractional numbers, like 5.5, 100.0, or 3.14159274. Each floating-point type has its own possible range and precision. The floating-point types in the standard library are Float, Double, and Float80 where available. 浮動小数点型は、5.5、100.0、または3.14159274のような、小数を表すために使われます。各浮動小数点型は、それ独自の可能な範囲と精度を持ちます。標準ライブラリにおける浮動小数点型は、Float、Double、そして利用可能なところではFloat80です。

Create new instances of floating-point types using integer or floating-point literals. For example: 浮動小数点型の新しいインスタンスを、整数または浮動小数点リテラルを使って作成してください。例えば：

let temperature = 33.2
let recordHigh = 37.5

The FloatingPoint protocol declares common arithmetic operations, so you can write functions and algorithms that work on any floating-point type. The following example declares a function that calculates the length of the hypotenuse of a right triangle given its two perpendicular sides. Because the hypotenuse(_:_:) function uses a generic parameter constrained to the FloatingPoint protocol, you can call it using any floating-point type. FloatingPointプロトコルは通常の算術演算子を宣言します、それであなたは何らかの浮動小数点型上で働く関数およびアルゴリズムを書くことができます。以下の例はある関数を宣言します、それは、それの２つの直角側を与えられる直角三角形の斜辺の長さを計算します。hypotenuse(_:_:)関数はFloatingPointプロトコルに制約された総称体パラメータを使うので、あなたはそれを呼び出すことがあらゆる浮動小数点型を使って行えます。

func hypotenuse<T: FloatingPoint>(_ a: T, _ b: T) -> T {
    return (a * a + b * b).squareRoot()
}


let (dx, dy) = (3.0, 4.0)
let distance = hypotenuse(dx, dy)
// distance == 5.0

Floating-point values are represented as a sign and a magnitude, where the magnitude is calculated using the type’s radix and the instance’s significand and exponent. This magnitude calculation takes the following form for a floating-point value x of type F, where ** is exponentiation: 浮動小数点値は、符号と規模として表されます、そこにおいて規模はその型のもつ基数とインスタンスの仮数と指数を使って計算されます。この規模計算は、型Fの浮動小数点値xに対して以下の形式をとります、そこで**は冪演算です：

x.significand * F.radix ** x.exponent

Here’s an example of the number -8.5 represented as an instance of the Double type, which defines a radix of 2. ここにDouble型のあるインスタンスとして表される数-8.5の例があります、それは２の基数を定義します。

let y = -8.5
// y.sign == .minus
// y.significand == 1.0625
// y.exponent == 3


let magnitude = 1.0625 * Double(2 ** 3)
// magnitude == 8.5

Types that conform to the FloatingPoint protocol provide most basic (clause 5) operations of the IEEE 754 specification. The base, precision, and exponent range are not fixed in any way by this protocol, but it enforces the basic requirements of any IEEE 754 floating-point type. FloatingPointプロトコルに準拠する型は、IEEE 754仕様の最も基本的な演算（５項）を提供します。基数、精度、そして指数範囲は、このプロトコルによって何らかの方法で固定されません、しかしそれはIEEE 754浮動小数点型どれかの基本要件を強要します。

Additional Considerations 追加の考慮すべきこと

In addition to representing specific numbers, floating-point types also have special values for working with overflow and nonnumeric results of calculation. 特定の数を表すことに加えて、浮動小数点型はまた、オーバーフローおよび非数の計算結果で使うための特別な値を持ちます。

Infinity 無限大

Any value whose magnitude is so great that it would round to a value outside the range of representable numbers is rounded to infinity. For a type F, positive and negative infinity are represented as F.infinity and -F.infinity, respectively. Positive infinity compares greater than every finite value and negative infinity, while negative infinity compares less than every finite value and positive infinity. Infinite values with the same sign are equal to each other. それの規模が大きすぎるので表現可能な数の範囲外の値に丸められるであろう何らかの値は、無限大に丸められます。型Fに対して、正と負の無限大はそれぞれF.infinityと-F.infinityのように表されます。正の無限大はすべての有限値と負の無限大より大きいと比較されます、一方負の無限大はすべての有限値と正の無限大より小さいと比較されます。同じ符号を持つ無限大値は互いに等しいです。

let values: [Double] = [10.0, 25.0, -10.0, .infinity, -.infinity]
print(values.sorted())
// Prints "[-inf, -10.0, 10.0, 25.0, inf]"

Operations with infinite values follow real arithmetic as much as possible: Adding or subtracting a finite value, or multiplying or dividing infinity by a nonzero finite value, results in infinity. 無限大値を伴う演算は、実数算術にできうる限り従います：ある無限大値を加算や減算すること、または非ゼロの有限値によって無限に乗算や除算することは、無限大の結果になります。

NaN (“not a number”) NaN（「非数」）

Floating-point types represent values that are neither finite numbers nor infinity as NaN, an abbreviation for “not a number.” Comparing a NaN with any value, including another NaN, results in false. 浮動小数点型は、有限数でも無限大でもない値を「not a number」の略語、NaNで表します。NaNを別のNaNを含む何らかの値と比較することは、falseの結果になります。

let myNaN = Double.nan
print(myNaN > 0)
// Prints "false"
print(myNaN < 0)
// Prints "false"
print(myNaN == .nan)
// Prints "false"

Because testing whether one NaN is equal to another NaN results in false, use the isNaN property to test whether a value is NaN. あるNaNが別のNaNと等しいかどうかテストすることはfalseの結果になることから、isNaNプロパティを使うことである値がNaNかどうかテストしてください。

print(myNaN.isNaN)
// Prints "true"

NaN propagates through many arithmetic operations. When you are operating on many values, this behavior is valuable because operations on NaN simply forward the value and don’t cause runtime errors. The following example shows how NaN values operate in different contexts. NaNは、いくつもの算術演算をずっと伝播していきます。あなたが沢山の値に演算を行っている時、この挙動は有益です、なぜならNaNに関する演算は単にその値を次に伝えて実行時エラーを起こさないからです。以下の例は、どのようにNaN値が異なる前後関係において作動するかを示します。

Imagine you have a set of temperature data for which you need to report some general statistics: the total number of observations, the number of valid observations, and the average temperature. First, a set of observations in Celsius is parsed from strings to Double values: あなたが幾つかの一般統計：観測総数、有効観測数、そして平均温度を報告しなければならない一揃いの温度データを持つと想像してください。まず、摂氏での観測の一揃いは、文字列からDouble値へ解析されます：

let temperatureData = ["21.5", "19.25", "27", "no data", "28.25", "no data", "23"]
let tempsCelsius = temperatureData.map { Double($0) ?? .nan }
print(tempsCelsius)
// Prints "[21.5, 19.25, 27, nan, 28.25, nan, 23.0]"

Note that some elements in the temperatureData array are not valid numbers. When these invalid strings are parsed by the Double failable initializer, the example uses the nil-coalescing operator (??) to provide NaN as a fallback value. temperatureData 配列の幾つかの要素は有効な数字ではないことに注意してください。それら無効な文字列がDoubleの失敗できるイニシャライザによって解析される場合のため、この例はnil合体演算子（??）を使ってNaNをフォールバック（頼みの綱の、予備の）値として提供します。

Next, the observations in Celsius are converted to Fahrenheit: 次に、摂氏での観測は華氏に変換されます：

let tempsFahrenheit = tempsCelsius.map { $0 * 1.8 + 32 }
print(tempsFahrenheit)
// Prints "[70.7, 66.65, 80.6, nan, 82.85, nan, 73.4]"

The NaN values in the tempsCelsius array are propagated through the conversion and remain NaN in tempsFahrenheit. tempsCelsius配列の中のNaN値は、変換を通して伝播されていき、tempsFahrenheitにおいてNaNのままです。

Because calculating the average of the observations involves combining every value of the tempsFahrenheit array, any NaN values cause the result to also be NaN, as seen in this example: 観測の平均の算出はtempsFahrenheit配列のすべての値を足し合わせることを必然的に含むことから、何らかのNaN値はまたNaNになるという結果を引き起こします、この例で見られるように：

let badAverage = tempsFahrenheit.reduce(0.0, +) / Double(tempsFahrenheit.count)
// badAverage.isNaN == true

Instead, when you need an operation to have a specific numeric result, filter out any NaN values using the isNaN property. そうではなく、あなたがある特定の数値結果を持つ演算を必要とする場合、あらゆるNaN値をisNaN特性を使って除去してください。

let validTemps = tempsFahrenheit.filter { !$0.isNaN }
let average = validTemps.reduce(0.0, +) / Double(validTemps.count)

Finally, report the average temperature and observation counts: 最後に、平均温度と観測数を報告します：

print("Average: \(average)°F in \(validTemps.count) " +
      "out of \(tempsFahrenheit.count) observations.")
// Prints "Average: 74.84°F in 5 out of 7 observations."