Bitwise NOT Operator
ビット単位の論理否定演算子

The bitwise NOT operator (~) inverts all bits in a number:
ビット単位の論理否定演算子（~）は、ある数の中の全てのビットを逆にします：

The bitwise NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space:
ビット単位の論理否定演算子は、接頭辞演算子で、少しの空白なしで、それが作用する値の直前に現れまます：

UInt8 integers have eight bits and can store any value between 0 and 255. This example initializes a UInt8 integer with the binary value 00001111, which has its first four bits set to 0, and its second four bits set to 1. This is equivalent to a decimal value of 15.
UInt8整数は、８ビットを持ち、0と255の間でのどんな値でも格納することができます。この例は、UInt8整数を２進数の値00001111で初期化します、それは、その最初の４つのビットを0に設定して、次の４つのビットを1に設定します。これは、10進の値の15に等しいです。

The bitwise NOT operator is then used to create a new constant called invertedBits, which is equal to initialBits, but with all of the bits inverted. Zeros become ones, and ones become zeros. The value of invertedBits is 11110000, which is equal to an unsigned decimal value of 240.
ビット単位の論理否定演算子は、それからinvertedBitsと呼ばれる新しい定数をつくるために使われます、それは、initialBitsと等しいです、しかし全てのビットは逆にされます。ゼロは１になります、そして１はゼロになります。invertedBitsの値は11110000です、それは、符号なし10進の値の240と等しいです。

Bitwise AND Operator
ビット単位の論理積演算子

The bitwise AND operator (&) combines the bits of two numbers. It returns a new number whose bits are set to 1 only if the bits were equal to 1 in both input numbers:
ビット単位の論理積演算子（&）は、２つの数のビットを結合します。それはある新しい数を返します、それのビットは両方の入力数においてビットが1と等しかった場合にだけ1に設定されます：

In the example below, the values of firstSixBits and lastSixBits both have four middle bits equal to 1. The bitwise AND operator combines them to make the number 00111100, which is equal to an unsigned decimal value of 60:
下記の例で、firstSixBitsとlastSixBitsの値は、1と等しい４つの中間のビットを両方とも持ちます。ビット単位の論理積演算子は、それらを結合して、数00111100をつくります、それは、符号なしの10進数の60と等しいです：

Bitwise OR Operator
ビット単位の論理和演算子

The bitwise OR operator (|) compares the bits of two numbers. The operator returns a new number whose bits are set to 1 if the bits are equal to 1 in either input number:
ビット単位の論理和演算子（|）は、２つの数のビットを比較します。この演算子は、どちらかの入力数においてビットが1と等しいならばビットが1に設定される、ある新しい数を返します：

In the example below, the values of someBits and moreBits have different bits set to 1. The bitwise OR operator combines them to make the number 11111110, which equals an unsigned decimal of 254:
下記の例で、someBitsとmoreBitsの値は、1に設定される異なるビットを持ちます。ビット単位の論理和演算子は、それらを結合して、数11111110を作ります、それは、符号なしの10進数の254と等しいです：

Bitwise XOR Operator
ビット単位の排他的論理和演算子

The bitwise XOR operator, or “exclusive OR operator” (^), compares the bits of two numbers. The operator returns a new number whose bits are set to 1 where the input bits are different and are set to 0 where the input bits are the same:
ビット単位の排他的論理和（XOR）演算子、あるいは「排他的論理和演算子」（^）は、２つの数のビットを比較します。この演算子は、入力ビットたちが異なっている所で1に設定され、入力ビットたちが同じである所で0に設定される、ある新しい数を返します：

In the example below, the values of firstBits and otherBits each have a bit set to 1 in a location that the other does not. The bitwise XOR operator sets both of these bits to 1 in its output value. All of the other bits in firstBits and otherBits match and are set to 0 in the output value:
下記の例で、firstBitsとotherBitsそれぞれの値は、他のものがそうでない場所で、ビットを1に設定されます。ビット単位の排他的論理和演算子は、これらのビットの両方ともその出力値において1に設定します。firstBitsとotherBitsでの他の全てのビットは一致していて、出力値において0に設定されます：

Bitwise Left and Right Shift Operators
ビット単位の左および右シフト演算子

The bitwise left shift operator (<<) and bitwise right shift operator (>>) move all bits in a number to the left or the right by a certain number of places, according to the rules defined below.
ビット単位の左シフト演算子（<<）とビット単位の右シフト演算子（>>）は、下で定義される規則に従ってある数の中の全てのビットを左または右に特定の桁数だけ移動します。（シフト：移す、ずらす）

Bitwise left and right shifts have the effect of multiplying or dividing an integer by a factor of two. Shifting an integer’s bits to the left by one position doubles its value, whereas shifting it to the right by one position halves its value.
ビット単位の左または右シフトは、２の因数によって、ある整数を掛けるまたは割る効果を持ちます。整数のビットを位置１つだけ左へ移すことはその値を２倍にします、一方それを位置１つだけ右へ移すことはその値を半分にします。

Shifting Behavior for Unsigned Integers
符号なし整数のためのシフト挙動

The bit-shifting behavior for unsigned integers is as follows:
符号なし整数のためのビットシフト挙動は、次の通りです：

1. Existing bits are moved to the left or right by the requested number of places.
   既存のビットは、左または右へ要請された桁数だけ動かされます。

2. Any bits that are moved beyond the bounds of the integer’s storage are discarded.
   整数の格納量の境界を越えて動かされるあらゆるビットは、捨てられます。

3. Zeros are inserted in the spaces left behind after the original bits are moved to the left or right.
   元のビットが左または右へ移動した後に残される空きに、ゼロが差し込まれます。

This approach is known as a logical shift.
このやり方は、論理シフトとして知られています。

The illustration below shows the results of 11111111 << 1 (which is 11111111 shifted to the left by 1 place), and 11111111 >> 1 (which is 11111111 shifted to the right by 1 place). Blue numbers are shifted, gray numbers are discarded, and orange zeros are inserted:
下のイラストは、11111111 << 1（それは、1桁だけ左へシフトされる11111111です）、そして11111111 >> 1（それは、1桁だけ右へシフトされる11111111です）の結果を示します。青色の数はシフトされます、灰色の数は捨てられます、そしてオレンジ色のゼロが差し込まれます：

Here’s how bit shifting looks in Swift code:
ビットシフトがスウィフトコードにおいてどのように見えるかは、ここにあります：

1. let shiftBits: UInt8 = 4 // 00000100 in binary
2. shiftBits << 1 // 00001000
3. shiftBits << 2 // 00010000
4. shiftBits << 5 // 10000000
5. shiftBits << 6 // 00000000
6. shiftBits >> 2 // 00000001

You can use bit shifting to encode and decode values within other data types:
あなたは、他のデータ型内の値を符号化したり復号するために、ビットシフトを使うことができます：

1. let pink: UInt32 = 0xCC6699
2. let redComponent = (pink & 0xFF0000) >> 16 // redComponent is 0xCC, or 204
3. let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent is 0x66, or 102
4. let blueComponent = pink & 0x0000FF // blueComponent is 0x99, or 153

This example uses a UInt32 constant called pink to store a Cascading Style Sheets color value for the color pink. The CSS color value #CC6699 is written as 0xCC6699 in Swift’s hexadecimal number representation. This color is then decomposed into its red (CC), green (66), and blue (99) components by the bitwise AND operator (&) and the bitwise right shift operator (>>).
この例は、ピンク色のカスケーディング・スタイル・シートの色値を保存するために、pinkと呼ばれるUInt32定数を使います。CSS色値#CC6699は、スウィフトの16進数表現では0xCC6699のように書かれます。この色はそれから、ビット単位の論理積演算子（&）とビット単位の右シフト演算子（>>）によって、それの赤（CC）、緑（66）、そして青（99）の構成要素に分解されます。

The red component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0xFF0000. The zeros in 0xFF0000 effectively “mask” the second and third bytes of 0xCC6699, causing the 6699 to be ignored and leaving 0xCC0000 as the result.
赤の構成要素は、数0xCC6699と0xFF0000との間のビット単位の論理積を実行することによって得られます。0xFF0000のゼロは、0xCC6699の２番目と３番目のバイトを効果的に「マスク」します（隠して消します）、そして6699が無視されるようになって、結果として0xCC0000が残ります。

This number is then shifted 16 places to the right (>> 16). Each pair of characters in a hexadecimal number uses 8 bits, so a move 16 places to the right will convert 0xCC0000 into 0x0000CC. This is the same as 0xCC, which has a decimal value of 204.
この数は、それから右に16桁シフトされます（>> 16）。16進数の中の文字の各ペアは８ビットを使うので、右への16桁の移動は0xCC0000を0x0000CCへと変えます。これは0xCCと同じものです、それは、10進の値の204を持ちます。

Similarly, the green component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x00FF00, which gives an output value of 0x006600. This output value is then shifted eight places to the right, giving a value of 0x66, which has a decimal value of 102.
同じように、緑の構成要素は数0xCC6699と0x00FF00との間のビット単位の論理積を実行することによって得られます、それは、0x006600の出力値を与えます。この出力値は、それから８桁右にシフトされて、0x66の値を与えます、それは10進の値の102を持ちます。

Finally, the blue component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x0000FF, which gives an output value of 0x000099. There’s no need to shift this to the right, as 0x000099 already equals 0x99, which has a decimal value of 153.
最後に、青の構成要素は数0xCC6699と0x0000FFとの間のビット単位の論理積を実行することによって得られます、それは、0x000099の出力値を与えます。0x000099がすでに0x99に等しいので、これを右へシフトする必要はありません、それは10進の値の153を持ちます。

Shifting Behavior for Signed Integers
符号つき整数のためのシフト挙動

The shifting behavior is more complex for signed integers than for unsigned integers, because of the way signed integers are represented in binary. (The examples below are based on 8-bit signed integers for simplicity, but the same principles apply for signed integers of any size.)
シフト挙動は、符号つき整数では符号なし整数よりももっと複雑です、なぜなら、符号つき整数が２進数において表される方法のためです。（下の例は、単純さのために8ビット符号つき整数に基づきます、しかし同じ原理はあらゆるサイズの符号つき整数に当てはまります）。

Signed integers use their first bit (known as the sign bit) to indicate whether the integer is positive or negative. A sign bit of 0 means positive, and a sign bit of 1 means negative.
符号つき整数は、それらの最初のビット（符号ビットとして知られるもの）を使って、その整数が正であるか負であるかを示します。0の符号ビットは正を意味します、そして、1の符号ビットは負であることを意味します。

The remaining bits (known as the value bits) store the actual value. Positive numbers are stored in exactly the same way as for unsigned integers, counting upwards from 0. Here’s how the bits inside an Int8 look for the number 4:
残っているビット（値ビットとして知られるもの）は、実際の値を格納します。正の数は符号なし整数と正確に同じ方法で格納されて、0から上方へ数えます。Int8内のビットが数4に対してどのように見えるかは、ここにあります：

The sign bit is 0 (meaning “positive”), and the seven value bits are just the number 4, written in binary notation.
符号ビットは0です（「正」を意味します）、そして７つの値ビットはちょうど、２進数表記法で書かれる数4です。

Negative numbers, however, are stored differently. They are stored by subtracting their absolute value from 2 to the power of n, where n is the number of value bits. An eight-bit number has seven value bits, so this means 2 to the power of 7, or 128.
負の数は、しかし異なって格納されます。それらは、2のn乗からそれらの絶対値を減ずることによって格納されます、そこで、nは値ビットの数です。８ビットの数は７つの値ビットを持ちますので、これは2の7乗、つまり128を意味します。

Here’s how the bits inside an Int8 look for the number -4:
Int8内のビットが数-4に対してどのように見えるかは、ここにあります：

This time, the sign bit is 1 (meaning “negative”), and the seven value bits have a binary value of 124 (which is 128 - 4):
今度は、符号ビットは1です（「負」を意味します）、そして、７つの値ビットは２進数の値の124を持ちます（それは、128 - 4です）：

This encoding for negative numbers is known as a two’s complement representation. It may seem an unusual way to represent negative numbers, but it has several advantages.
この負数のための符号化は、２の補数表現として知られています。それは負数を表す普通でない方法のようかもしれません、しかしそれはいくつかの利点を持ちます。

First, you can add -1 to -4, simply by performing a standard binary addition of all eight bits (including the sign bit), and discarding anything that doesn’t fit in the eight bits once you’re done:
第１に、あなたは-1を-4に加えることが、単純に８つのビット全て（符号ビットを含む）の通常のバイナリの加算を実行して、あなたがそうしたならばその８ビットに収まらない何でも捨てることによって行えます：

Second, the two’s complement representation also lets you shift the bits of negative numbers to the left and right like positive numbers, and still end up doubling them for every shift you make to the left, or halving them for every shift you make to the right. To achieve this, an extra rule is used when signed integers are shifted to the right: When you shift signed integers to the right, apply the same rules as for unsigned integers, but fill any empty bits on the left with the sign bit, rather than with a zero.
第２に、２の補数表現はまた、あなたに負数のビットを左や右に正の数のようにシフトさせます、そして依然としてあなたが左へとするシフトは全てそれを２倍にすることで、またあなたが右へとするシフトは全てそれを半分にすることで終わります。これを達成するために、符号つき整数が右へシフトされるとき、特別な規則が使われます：あなたが符号つき整数を右にシフトする時は、符号なし整数と同じ規則を適用してください、しかし、その左のあらゆる空のビットを、ゼロではなく符号ビットで満たしてください。

This action ensures that signed integers have the same sign after they are shifted to the right, and is known as an arithmetic shift.
この動作は、符号つき整数が、それが右へシフトされた後に同じサインを持つことを確実にします、そして算術シフトとして知られています。

Because of the special way that positive and negative numbers are stored, shifting either of them to the right moves them closer to zero. Keeping the sign bit the same during this shift means that negative integers remain negative as their value moves closer to zero.
正および負の数が格納される特別な方法のため、それらのどちらでも右へシフトすることは、それらをゼロの近くに動かします。このシフトの間に符号ビットを同じに保つことは、それの値がゼロの近くに動くとき、負整数が負のままであることを意味します。

Value Overflow
値オーバフロー

Numbers can overflow in both the positive and negative direction.
数は正と負の向きの両方においてオーバフローすることができます。

Here’s an example of what happens when an unsigned integer is allowed to overflow in the positive direction, using the overflow addition operator (&+):
ここに、オーバフロー加算演算子（&+）を使用して、正の向きにおいて符号なし整数がオーバフローを許されるとき何が起こるかの例があります：

The variable unsignedOverflow is initialized with the maximum value a UInt8 can hold (255, or 11111111 in binary). It is then incremented by 1 using the overflow addition operator (&+). This pushes its binary representation just over the size that a UInt8 can hold, causing it to overflow beyond its bounds, as shown in the diagram below. The value that remains within the bounds of the UInt8 after the overflow addition is 00000000, or zero.
変数unsignedOverflowは、UInt8が持つことができる最大限の値で初期化されます（255、または２進数での11111111）。それは、それからオーバフロー加算演算子（&+）を使って1だけ増やされます。これは、そのバイナリの表現をちょうどUInt8が持つことができる大きさ以上に押し広げて、それを、下の図で示すように、その境界を越えてあふれさせます。オーバフロー加算の後でUInt8の領域内に残る値は、00000000、またはゼロです：

Something similar happens when an unsigned integer is allowed to overflow in the negative direction. Here’s an example using the overflow subtraction operator (&-):
符号なし整数が負の向きにおいてオーバフローを認められるときに同じようなことが起こります。ここにオーバフロー減算演算子（&-）を使った例があります：

The minimum value that a UInt8 can hold is zero, or 00000000 in binary. If you subtract 1 from 00000000 using the overflow subtraction operator (&-), the number will overflow and wrap around to 11111111, or 255 in decimal.
UInt8が持つことができる最小限の値は、０、または２進数では00000000です。あなたがオーバフロー減算演算子（&-）を使用して00000000から1を減ずるならば、その数はあふれ出てぐるっと送り込まれて11111111、10進での255になります：

Overflow also occurs for signed integers. All addition and subtraction for signed integers is performed in bitwise fashion, with the sign bit included as part of the numbers being added or subtracted, as described in Bitwise Left and Right Shift Operators.
オーバフローはまた、符号つき整数に対しても起こります。符号つき整数に対する全ての加算と減算は、ビット単位の左および右シフト演算子で記述されるように、加算または減算される数の一部として含めらる符号ビットとともに、ビット単位流儀で実行されます。

The minimum value that an Int8 can hold is -128, or 10000000 in binary. Subtracting 1 from this binary number with the overflow operator gives a binary value of 01111111, which toggles the sign bit and gives positive 127, the maximum positive value that an Int8 can hold.
Int8が持つことができる最小限の数は、-128、または２進数での10000000です。この２進数からオーバフロー演算子を使って1を減ずることは、２進数の01111111を与えます、それは符号ビットを切り替えて正の127、Int8が持つことができる最大限の正の値、を与えます。

For both signed and unsigned integers, overflow in the positive direction wraps around from the maximum valid integer value back to the minimum, and overflow in the negative direction wraps around from the minimum value to the maximum.
符号つきおよび符号なし整数の両方に対して、正の方向でのオーバフローは最大限の有効な整数値から逆に最小限へとぐるっと送り込まれ、負の方向でのオーバフローは最小限の値から最大限へとぐるっと送り込まれます。

Prefix and Postfix Operators
接頭辞と接尾辞演算子

The example shown above demonstrates a custom implementation of a binary infix operator. Classes and structures can also provide implementations of the standard unary operators. Unary operators operate on a single target. They are prefix if they precede their target (such as -a) and postfix operators if they follow their target (such as b!).
上で示される例は、二項接中辞演算子のあつらえの実装を示します。クラスと構造体は、また、標準の単項演算子の実施も提供することができます。単項演算子は、一つの目標に作用します。それらは、それがその目標に先行するならば接頭辞（例えば-a）、それがその目標の後に続くならば接尾辞演算子です（例えばb!）。

You implement a prefix or postfix unary operator by writing the prefix or postfix modifier before the func keyword when declaring the operator method:
あなたは、接頭辞または接尾辞単項演算子を、prefixまたはpostfix修飾子をfuncキーワードの前に演算子メソッドを宣言するときに書くことによって実装します：

The example above implements the unary minus operator (-a) for Vector2D instances. The unary minus operator is a prefix operator, and so this method has to be qualified with the prefix modifier.
上の例は、Vector2Dインスタンスのための単項マイナス演算子（-a）を実装します。この単項マイナス演算子は、接頭辞演算子です、なのでこのメソッドはprefix修飾子で修飾されます。

For simple numeric values, the unary minus operator converts positive numbers into their negative equivalent and vice versa. The corresponding implementation for Vector2D instances performs this operation on both the x and y properties:
単純な数の値のために、この単項マイナス演算子は正の数をその負の等価物に変えます、逆の場合も同じです。Vector2Dインスタンスのための対応する実装は、xとyプロパティ両方の上でこの操作を実行します：

Compound Assignment Operators
複合代入演算子

Compound assignment operators combine assignment (=) with another operation. For example, the addition assignment operator (+=) combines addition and assignment into a single operation. You mark a compound assignment operator’s left input parameter type as inout, because the parameter’s value will be modified directly from within the operator method.
複合代入演算子は、代入（=）を別の操作と組み合わせます。例えば、加算代入演算子（+=）は、加算と代入を一回の操作に結合します。あなたは複合代入演算子の左入力パラメーター型をinoutとして印します、なぜなら、このパラメーターの値は直接にこの演算子メソッド内で修正されることになるからです。

The example below implements an addition assignment operator method for Vector2D instances:
下の例は、Vector2Dインスタンスのために追加代入演算子メソッドを実装します：

Because an addition operator was defined earlier, you don’t need to reimplement the addition process here. Instead, the addition assignment operator method takes advantage of the existing addition operator method, and uses it to set the left value to be the left value plus the right value:
加算演算子は以前に定義されたので、あなたはここでは加算プロセスを再実装する必要はありません。代わりに、追加代入演算子メソッドは、既存の加算演算子メソッドを利用して、左の値を右の値を加えた左の値に設定するためにそれを使います：

Equivalence Operators
同等演算子

By default, custom classes and structures do not receive a default implementation of the equivalence operators, known as the “equal to” operator (==) and “not equal to” operator (!=).
初期状態では、あつらえのクラスと構造体は、「同等」演算子（==）そして「不等」演算子（!=）として知られる、同等演算子の省略時の実装を受け取りません。

To use the equivalence operators to check for equivalence of your own custom type, provide an implementation of the “equal to” operator in the same way as for other infix operators, and add conformance to the standard library’s Equatable protocol:
あなた独自のあつらえの型の同等について調べるために同等演算子を使用するには、「同等」演算子の実装を他の接中辞演算子と同じやり方で提供してください、そして標準ライブラリのEquatableプロトコルに対する準拠を加えてください：

The above example implements an “equal to” operator (==) to check if two Vector2D instances have equivalent values. In the context of Vector2D, it makes sense to consider “equal” as meaning “both instances have the same x values and y values”, and so this is the logic used by the operator implementation. The standard library provides a default implementation of the “not equal to” operator (!=), which simply returns the inverse of the result of the “equal to” operator.
上記の例は、ある「同等」演算子（==）を実装して、２つのVector2Dインスタンスが同じ値を持つかどうか調べます。Vector2Dの文脈では、「同等」を「両方のインスタンスが同じx値とy値を持つ」ことを意味すると考えるのが道理にかなっています、なのでそれが演算子実装によって使われる論理です。標準ライブラリは、「不等」演算子（!=）の省略時の実装を提供します、それは単に「同等」演算子の結果の反対を返します。

You can now use these operators to check whether two Vector2D instances are equivalent:
あなたは、現在２つのVector2Dインスタンスが等しいかどうか調べるために、これらの演算子を使用することができます：

Swift provides synthesized implementations of the equivalence operators for the following kinds of custom types:
スウィフトは、同等演算子の合成実装を以下の種類のあつらえの型に対して提供します：

• Structures that have only stored properties that conform to the Equatable protocol
  Equatableプロトコルに準拠する格納プロパティだけを持つ構造体

• Enumerations that have only associated types that conform to the Equatable protocol
  Equatableプロトコルに準拠する関連型だけを持つ列挙

• Enumerations that have no associated types
  関連型を持たない列挙

Declare Equatable conformance as part of the type’s original declaration to receive these default implementations.
Equatable準拠をその型の持つ元の宣言の一部として宣言して、それら省略時の実装を受け取ってください。

The example below defines a Vector3D structure for a three-dimensional position vector (x, y, z), similar to the Vector2D structure. Because the x, y, and z properties are all of an Equatable type, Vector3D receives default implementations of the equivalence operators.
下の例は、Vector3D構造体を３次元の位置ベクトル(x, y, z)に対して定義します、Vector2D構造体に似たものです。x、y、そしてzプロパティはまったくのEquatable型なので、Vector3Dは同等演算子の省略時の実装いろいろを受け取ります。

Precedence for Custom Infix Operators
あつらえの接中辞演算子の優先順位

Custom infix operators each belong to a precedence group. A precedence group specifies an operator’s precedence relative to other infix operators, as well as the operator’s associativity. See Precedence and Associativity for an explanation of how these characteristics affect an infix operator’s interaction with other infix operators.
あつらえの接中辞演算子それぞれは、ある優先順位グループに属しています。優先順位グループは、他の接中辞演算子と相対的にある演算子の優先順位を、それだけでなく演算子の結合性も指定します。優先順位と結合性をどのようにそれらの特徴が接中辞演算子の他の接中辞演算子との相互作用に影響を及ぼすかの解説として見てください。

A custom infix operator that is not explicitly placed into a precedence group is given a default precedence group with a precedence immediately higher than the precedence of the ternary conditional operator.
ある優先順位グループの中に明示的に置かれないあつらえの接中辞演算子は、三項条件演算子の優先順位のすぐ上の優先順位を持つ省略時の優先順位グループを与えられます。

The following example defines a new custom infix operator called +-, which belongs to the precedence group AdditionPrecedence:
以下の例は、+-と呼びれる新しいあつらえの接中辞演算子を定義します、それは優先順位グループAdditionPrecedenceに属します：

This operator adds together the x values of two vectors, and subtracts the y value of the second vector from the first. Because it is in essence an “additive” operator, it has been given the same precedence group as additive infix operators such as + and -. For information about the operators provided by the Swift standard library, including a complete list of the operator precedence groups and associativity settings, see Operator Declarations. For more information about precedence groups and to see the syntax for defining your own operators and precedence groups, see Operator Declaration.
この演算子は、２つのベクトルのx値を一緒に加えて、第二のベクトルのy値を最初のものから減じます。それは本質的には「加法的な」演算子であるので、それは+や-といった加法的な接中辞演算子と同じ優先順位グループを与えられています。スウィフト標準ライブラリによって提供される演算子についての情報として、演算子優先順位と結合性の設定の完全なリストを含めて、演算子宣言を見てください。優先順位グループについてのさらなる情報として、そしてあなた独自の演算子と優先順位グループを定義するための構文を見るには、演算子宣言を見てください。