BinaryInteger

Overview 概要

The BinaryInteger protocol is the basis for all the integer types provided by the standard library. All of the standard library’s integer types, such as Int and UInt32, conform to BinaryInteger. BinaryIntegerプロトコルは、標準ライブラリによって提供される全ての整数型の土台です。標準ライブラリの持つ整数型の全て、例えばIntとUInt32などは、BinaryIntegerに準拠します。

Converting Between Numeric Types 数値型の間で変換する

You can create new instances of a type that conforms to the BinaryInteger protocol from a floating-point number or another binary integer of any type. The BinaryInteger protocol provides initializers for four different kinds of conversion. あなたは、ある型の新しいインスタンスでBinaryIntegerプロトコルに準拠するものを、浮動小数点数またはどんな型であれ別のバイナリ整数から作成できます。BinaryIntegerプロトコルは、イニシャライザを４つの異なる種類の変換に対して提供します。

Range-Checked Conversion 範囲確認変換

You use the default init(_:) initializer to create a new instance when you’re sure that the value passed is representable in the new type. For example, an instance of Int16 can represent the value 500, so the first conversion in the code sample below succeeds. That same value is too large to represent as an Int8 instance, so the second conversion fails, triggering a runtime error. あなたは、省略時のinit(_:)イニシャライザを使って新しいインスタンスを作成するのは、渡される値が新しい型において表現可能であるとあなたが確信する場合です。例えば、Int16のインスタンスは値500を表せます、それで下のコード例の最初の変換は成功します。その同じ値は、Int8インスタンスとして表すには大きすぎます、それで２番目の変換は、実行時エラーを引き起こして失敗します。

let x: Int = 500
let y = Int16(x)
// y == 500


let z = Int8(x)
// Error: Not enough bits to represent...

When you create a binary integer from a floating-point value using the default initializer, the value is rounded toward zero before the range is checked. In the following example, the value 127.75 is rounded to 127, which is representable by the Int8 type. 128.25 is rounded to 128, which is not representable as an Int8 instance, triggering a runtime error. あなたがバイナリ整数をある浮動小数点力省略時のイニシャライザを使って作成するとき、その値は範囲が検査される前にゼロへの丸めをされます。続く例において、値127.75は127へ丸められます、それはInt8型によって表現可能です。128.25は、128へ丸められます、それはInt8インスタンスによって表現可能ではなく、実行時エラーを引き起こします。

let e = Int8(127.75)
// e == 127


let f = Int8(128.25)
// Error: Double value cannot be converted...

Exact Conversion 厳密変換

Use the init?(exactly:) initializer to create a new instance after checking whether the passed value is representable. Instead of trapping on out-of-range values, using the failable init?(exactly:) initializer results in nil. init?(exactly:)イニシャライザを使うことで、その渡された値が表現可能であるかどうか調べた後に新しいインスタンスを作成してください。範囲外の値に関してトラップするのではなく、失敗できるinit?(exactly:)イニシャライザはnilという結果になります。

let x = Int16(exactly: 500)
// x == Optional(500)


let y = Int8(exactly: 500)
// y == nil

When converting floating-point values, the init?(exactly:) initializer checks both that the passed value has no fractional part and that the value is representable in the resulting type. 浮動小数点値を変換するとき、init?(exactly:)イニシャライザは、渡された値が小数部を持たないこと、そしてその値が結果となる型の中に表現可能であることの両方を検査します。

let e = Int8(exactly: 23.0)       // integral value, representable
// e == Optional(23)


let f = Int8(exactly: 23.75)      // fractional value, representable
// f == nil


let g = Int8(exactly: 500.0)      // integral value, nonrepresentable
// g == nil

Clamping Conversion 固定変換

Use the init(clamping:) initializer to create a new instance of a binary integer type where out-of-range values are clamped to the representable range of the type. For a type T, the resulting value is in the range T.min...T.max. init(clamping:)イニシャライザを使って、バイナリ整数型の新しいインスタンスを作成してください、そこにおいて範囲外の値はその型の表現可能な範囲に固定されます。型Tに対して、結果となる値は範囲T.min...T.maxの中です。

let x = Int16(clamping: 500)
// x == 500


let y = Int8(clamping: 500)
// y == 127


let z = UInt8(clamping: -500)
// z == 0

Bit Pattern Conversion ビットパターン変換

Use the init(truncatingIfNeeded:) initializer to create a new instance with the same bit pattern as the passed value, extending or truncating the value’s representation as necessary. Note that the value may not be preserved, particularly when converting between signed to unsigned integer types or when the destination type has a smaller bit width than the source type. The following example shows how extending and truncating work for nonnegative integers: init(truncatingIfNeeded:)イニシャライザを使って、渡された値と同じビットパターンを持つ新しいインスタンスを、必要ならばその値の表現を拡張または切り詰めて作成してください。注意すべきはその値が保たれないかもしれないことです、とりわけ符号付きから符号なし整数型への間の変換の場合、または行先の型が元の型より小さなビット幅を持つ場合には。後に続く例は、非負数整数に対する拡張および切り詰め作業の方法を示します：

let q: Int16 = 850
// q == 0b00000011_01010010


let r = Int8(truncatingIfNeeded: q)      // truncate 'q' to fit in 8 bits
// r == 82
//   == 0b01010010


let s = Int16(truncatingIfNeeded: r)     // extend 'r' to fill 16 bits
// s == 82
//   == 0b00000000_01010010

Any padding is performed by sign-extending the passed value. When nonnegative integers are extended, the result is padded with zeroes. When negative integers are extended, the result is padded with ones. This example shows several extending conversions of a negative value—note that negative values are sign-extended even when converting to an unsigned type. あらゆる詰め物は、渡された値を符号拡張することによって実行されます。非負整数が拡張される時、結果はゼロで詰め物をされます。負整数が拡張される時、結果は１で詰め物をされます。この例は、ある負の値のいくつかの拡張変換を示します — 符号なし型へ変換する時でさえ、負の値が符号拡張されることに注意してください。

let t: Int8 = -100
// t == -100
// t's binary representation == 0b10011100


let u = UInt8(truncatingIfNeeded: t)
// u == 156
// u's binary representation == 0b10011100


let v = Int16(truncatingIfNeeded: t)
// v == -100
// v's binary representation == 0b11111111_10011100


let w = UInt16(truncatingIfNeeded: t)
// w == 65436
// w's binary representation == 0b11111111_10011100

Comparing Across Integer Types さまざまな整数型を比較する

You can use relational operators, such as the less-than and equal-to operators (< and ==), to compare instances of different binary integer types. The following example compares instances of the Int, UInt, and UInt8 types: あなたは、関係演算子、例えばより小さいそして同等演算子（<そして==）などを使って、異なるバイナリ整数型のインスタンス同士を比較できます。以下の例は、Int、UInt、そしてUInt8型のインスタンスを比較します：

let x: Int = -23
let y: UInt = 1_000
let z: UInt8 = 23


if x < y {
    print("\(x) is less than \(y).")
}
// Prints "-23 is less than 1000."


if z > x {
    print("\(z) is greater than \(x).")
}
// Prints "23 is greater than -23."