Rubys Bitwise Toolbox：演算子、アプリケーション、および魔法のトリック

AND演算と同様に、2セットのビットにも適用される別の演算はビット単位のORです。そのシンボルは|です そしてこの論理に従います：

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

したがって、いずれかの側に1がある場合、結果は1になり、それ以外の場合は0になります。非常に単純です。より多くのビットを使用したOR演算を見てみましょう：

0110 OR
0111
-----
0111

そしてRubyで：

25.to_s(2)           # 11001
30.to_s(2)           # 11110
(25 | 30).to_s(2)    # 11111

実際の例1：権限

この時点で、なぜこれらの操作が役立つのか疑問に思われるかもしれません。結局のところ、それらはかなり低レベルのようです。ネットワークプロトコル、グラフィックス、または暗号化を直接操作する予定はない場合があります。

ただし、おそらく以前に権限を使用したことがあります。パーミッションは、ビット演算が非常に役立つ領域の1つです。ユーザーがドキュメント内でさまざまなアクションを実行できる権限システムがあるとします。

• 表示
• 編集
• 削除
• 他のユーザーを招待する

そして今、これらのアクションをさまざまな役割にモデル化したいと思います：

• アシスタント： ドキュメントを表示および編集できます。
• オブザーバー： ドキュメントのみを表示できます。
• 作成者： すべてのアクションを実行できます。

これをどのようにモデル化できますか？ユーザーがこれらの役割のいずれかを持っているかどうかをいつでも知るにはどうすればよいですか？ 1つの答えは、ビット演算を使用することです。

ユーザーごとに、ユーザーが持っている権限を表すビットのセットを1つだけ保存します。

(Starting from the right side)
1st bit: View
2nd bit: Edit
3rd bit: Delete
4th bit: Invite other users

例：

0001 = Can only view the document.
0011 = Can view and edit the document.
1001 = Can view, can't edit, can't delete and can invite others.

一部のユーザーにこれらの値を設定すると、必要な権限で非常に高速な比較を行うことができます。ユーザーがドキュメントを編集できるかどうかを確認しているとしましょう。ビットごとのAND演算を使用できます：

# This is called a bit mask. It contains only the value we want to check, in this case the second bit for editing.
EDIT_PERMISSION_MASK = 0b0010

# We can define a quick method to check this: 
def can_edit_document?(user_permisions)
  (EDIT_PERMISSION_MASK & user_permisions) != 0
end

これは、ビットごとのAND演算で0とは異なるものが得られる場合、そのビットが設定されていることを意味します。

0010 AND
1101
----
0000 == 0 so we don't have the permission

0010 AND
1110
----
0010 != 0 so we have the permission

チェックするビットの位置を変更することで、他のパーミッションに同じロジックを適用できるため、これらの定数と対応するメソッドを使用することになります。

VIEW_PERMISSION_MASK   = 0b0001
EDIT_PERMISSION_MASK   = 0b0010
DELETE_PERMISSION_MASK = 0b0100
INVITE_PERMISSION_MASK = 0b1000

さらに、簡単なビットチェックで、アクセス許可を動的に定義し、将来的に新しいアクセス許可を保存できます。

たとえば、アシスタントはドキュメントの表示と編集のみが可能であるため、そのユーザーの権限は0011になります。 。その値をデータベースに保存してから、アシスタントが前に定義したメソッドでアクションを実行できるかどうかを簡単に確認できます。

ASSISTANT_MASK = VIEW_PERMISSION_MASK | EDIT_PERMISSION_MASK
# This will be: 0011

# Optionally, we could use this method to check if this user is an assistant. This method could be defined inside the User class.
def is_assistant?(user)
  (user.permissions == ASSISTANT_MASK)
end

これらすべてがおなじみのように聞こえる場合、それはUnixベースのシステムのファイルパーミッションに一般的に使用されているのと同じアプローチだからです。

実際の例2：チーム内のポジション

もう少しビット単位の演算を使用しましょう😉。

比較的一般的な別のケース、つまりスポーツチームのさまざまな役職や会社の役職に適用できます。単純化するためにバスケットボールチームと一緒に行きましょう。

バスケットボールでは、ゲームをプレイするときに5つのポジションがあります。-ポイントガード-シューティングガード-スモールフォワード-パワーフォワード-センター

そして、各位置にビットのセットを割り当てることができます： 00001 Point guard 00010 Shooting guard 00100 Small forward 01000 Power forward 10000 Center

Rubyでも同じです：

POINT_GUARD_POSITION    = 0b00001
SHOOTING_GUARD_POSITION = 0b00010
SMALL_FORWARD_POSITION  = 0b00100
POWER_FORWARD_POSITION  = 0b01000
CENTER_POSITION         = 0b10000

POINT_GUARD_POSITION | SHOOTING_GUARD_POSITION | SMALL_FORWARD_POSITION | POWER_FORWARD_POSITION | CENTER_POSITION # = 31

これで、チーム全体が参加しているかどうかを確認するなど、いくつかの興味深いことができるようになりました。

# p1...p5 are the positions of each player
is_full_team_present = (p1 | p2 | p3 | p4 | p5 == 31)

なんで？ビット単位のOR演算を実行することにより、すべての位置があれば、最終的には11111になります。

# OR bitwise operation
00001 |
00010 |
00100 |
01000 |
10000
-----
11111

また、2 ^ 0 + 2 ^ 1 + 2 ^ 2 + 2 ^ 3 + 2 ^ 4 =31であるため、11111は31です。

これは厳密にはビット演算とは関係ありませんが、このデータモデリングを使用すると、2人のプレーヤーを交換できるかどうかを確認することもできます。これは非常に簡単です：

def can_be_exchanged?(player1, player2)
  player1.position == player2.position
end

XOR

2セットのビットで実行できるもう1つの操作は、シンボルが^であるXORです。 。

XORは排他的論理和を意味し、次のロジックに従います：

1 | 1 = 0
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

したがって、2つのビットの1つが1の場合にのみ、結果は1になります。両方が等しい場合は0になります。

x ^ x =0であるため、この演算は、数値をそれ自体と比較するために一部のアルゴリズムで使用されます。

00010111 left-shift
<-------
00101110

10010111 right-shift
------->
11001011

5.to_s(2) # 101
(5 << 2).to_s(2) # 10100

5.to_s(2) # 101
(5 >> 2).to_s(2) # 1

10.to_s(2)        # 1010
(10 >> 1).to_s(2) # 101
10 >> 1           # 5

10.to_s(2)        # 1010
(10 << 1).to_s(2) # 10100
10 << 1           # 20

2 = 00000010 &
    00000001
-------------
    00000000

4 = 00000100 &
    00000001
-------------
    00000000

5 = 00000101 &
    00000001
-------------
    00000001

def is_odd?(number)
  number & 1
end

def is_even?(number)
  is_odd?(number) == 0
end
# Or:
def is_even?(number)
  (number & 1) == 0
end