Python で疑似 n-bit int クラスを自作する

Python で疑似 n-bit int クラスを自作してみた．

# 背景

Cracking the Coding Interview を読んでいて，Bit Manipulation の章で実際にコードを書くとき Python の int が扱いづらかった．
Python の int には値の大きさに制限がないので．それに起因して整数値を 01 の並びとして扱うときに，下にあるようにいろいろ不便があった．



### 例 1. 負数のバイナリ表記が見づらい

Python のバイナリ表記は `[-]絶対値のバイナリ表記` がフォーマット．
簡単のため 8 bit の int 型を扱っていると想定．
0 は 8 bit で `b00000000` なので `~0` を計算すると `b11111111` となる．
これを Python で `~0` を計算して表示すると `-0000001` となる．
扱う bit 数に制限がないのでこういうフォーマットになるのも当然なんだけど，今回自分が使いたい用途ではちょっと見づらい．

```py
n = ~0
print(f"{n:08b}") # -0000001
```

### 例 2. 左シフトがトランケートされない

これも扱う bit 数に制限がないから当たり前なんだけど，左シフトしたときに扱いたい bit 数からはみ出た分がそのまま残る．
`15 = b1111` を左に 2 だけシフトさせることを考える．
8 bit の int 型の場合，15 を左に 2 だけシフトさせると `15 << 2 = b1100` となり，8 bit 分からあふれた先頭の `11` がトランケートされる．
一方 Python の場合は `15 << 2 = b111100` のまま．
決まった bit 数での int の計算を想定している場合，都合が悪いことがある．

```cpp
// C++
int8_t n = 15       // b1111
n <<= 2             // b1100
int8_t m = 1        // b0001
int8_t res = n | m  // b1101
```

```python
# Python
n = 15      # b1111
n <<= 2     # b111100
m = 1       # b000001
res = n | m # b111101
```


Python にも int32 や int64 みたいなのがないか調べたけど，見当たらなかったので自作してみた．

# 実行環境

- Python 3.8.5
- Docker Container: Ubuntu 20.04

32 bit 型 (Int32) だけはテストした（ソースコードとテスト: https://github.com/e5pe0n/algorithm-training/tree/master/cracking_the_coding_interview_6th/chapter05/python/bitint ）



# 自作整数型クラス Int の設計

## 欲しい機能

- 扱う bit 数を 32 bit や 64 bit に制限できる
  - `<<` での先頭ビットのトランケート
- 01 の並びが 2 の補数でアサインされたバイナリ表記を表示できる
  - 組込み関数 `format()` で `d` や `b` などフォーマットを指定できる
- Built-in の int と併用できる
  - `+` や `-` といった算術演算子を int と組み合わせて適用できる
  - `&` や `|` といったビット演算子を int と組み合わせて適用できる

# Int の実装

## コンストラクタ

コンストラクタ部分の全体

```py
class Int:
    def __init__(self, value: Union[int, str], bit: int):
        if bit <= 0:
            raise ValueError("bit must be greater than 0.")

        self.__bit: int = bit
        self.__max: int = (1 << (self.__bit - 1)) - 1
        self.__min: int = -self.__max - 1

        if isinstance(value, int):
            # range check
            if value < self.min:
                raise ValueError(
                    f"underflow in {self.__bit}-bit integer value. \
                        value must be between [{self.__min}, {self.__max}]")
            elif self.max < value:
                raise ValueError(
                    f"overflow in {self.bit}-bit integer value. \
                        value must be between [{self.__min}, {self.__max}]")

            if value >= 0:
                self.__value: int = value
                self.__bin: int = self.__value
            else:
                self.__value: int = value
                self.__bin: int = self.__cmpl(abs(self.__value))

        elif isinstance(value, str):
            if len(value) > self.__bit:
                raise ValueError(f"length of value must be between [1, {self.__bit}].")

            if not pat.match(value):
                raise ValueError("value must be a sequence of 0 and 1.")

            if len(value) == self.__bit and value[0] == '1':
                # MSB is 1 so we must calculate the complement
                self.__bin: int = int(value, 2)
                self.__value: int = -self.__cmpl(self.__bin)
            else:
                self.__value: int = int(value, 2)
                self.__bin: int = self.__value

        else:
            raise TypeError("value must be an int or a str object.")

    @property
    def bit(self) -> int:
        return self.__bit

    @property
    def bin(self) -> int:
        return self.__bin

    @property
    def value(self) -> int:
        return self.__value

    @property
    def max(self) -> int:
        return self.__max

    @property
    def min(self) -> int:
        return self.__min

    def __cmpl(self, n: int) -> int:
        return ((self.__max + 1) << 1) - n

...

def Int16(value):
    return Int(value, 16)


def Int32(value):
    return Int(value, 32)


def Int64(value):
    return Int(value, 64)
```

int とバイナリ表記の str (`value`) から，与えられた bit 数 (`bit`) の Int オブジェクトを作れるようにする．
`bit` が 0 以下の場合は ValueError を投げる．
`__max` は与えられた bit 数で扱える最大値，`__min` は最小値．

例えば 4 bit の場合は `__max = 1 << (4 - 1) - 1 = b1000 - 1 = 8 - 1 = 7`，`__min = -7 - 1 = -8` になる．
0 を表す分だけ `__max` の方が絶対値が小さい．

|positive integers|negative integers|
|:---:|:---:|
|7 (b0111)|-1 (b1111)|
|6 (b0110)|-2 (b1110)|
|5 (b0101)|-3 (b1101)|
|4 (b0100)|-4 (b1100)|
|3 (b0011)|-5 (b1011)|
|2 (b0010)|-6 (b1010)|
|1 (b0001)|-7 (b1001)|
|0 (b0000)|-8 (b1000)|

bit 数や最大値，最小値はオブジェクトの外部からも参照したいが代入されたくない．
ダンダー (Double Underscore: `__`) でマングリングして外部から隠し，代わりに `@propety` をつけてゲッターを用意しておく．

```py
def __init__(self, value: Union[int, str], bit: int):
    if bit <= 0:
        raise ValueError("bit must be greater than 0.")

    self.__bit: int = bit
    self.__max: int = (1 << (self.__bit - 1)) - 1
    self.__min: int = -self.__max - 1
```

```py
@property
def bit(self) -> int:
    return self.__bit

@property
def max(self) -> int:
    return self.__max

@property
def min(self) -> int:
    return self.__min
```

`value` が int の場合，`value` の値が `bit` 型整数値の最大値と最小値の範囲におさまっているかチェックする．

```py
if isinstance(value, int):
    # range check
    if value < self.min:
        raise ValueError(
            f"underflow in {self.__bit}-bit integer value. \
                value must be between [{self.__min}, {self.__max}]")
    elif self.max < value:
        raise ValueError(
            f"overflow in {self.bit}-bit integer value. \
                value must be between [{self.__min}, {self.__max}]")
```

`__bin` はバイナリ表記用の整数値を保持する．
4-bit int で -5 を扱うことを考える．
Python で -5 をバイナリ表記すると `-0101` となるが，2 の補数表現を使う場合は `1011` となる．
Int オブジェクトでは -5 をバイナリで表示する場合 `1011` と表示したい．
-5 + 5 = 0 i.e. `bxxxx + b0101 = b0000` から `-5 = b1011` が得られる．
トランケートされた 1 bit を考慮すると `b0xxxx + b00101 = b10000` i.e. `b0xxxx = b10000 - b00101 = 2^4 - 5 = 11 (b01011)` となり，b1011 の 10 進整数値は bit 数 4 と -5 の絶対値 5 から直接計算できることがわかる．
一般化して，`__bin = 2**__bit - abs(__value)`.
補数を計算する補助関数 `__cmpl()` では計算しておいた最大値 `__max` に 1 を足して 2 倍することで `2**__bit` を計算してる．


```py
if value >= 0:
    self.__value: int = value
    self.__bin: int = self.__value
else:
    self.__value: int = value
    self.__bin: int = self.__cmpl(abs(self.__value))
```

```py
def __cmpl(self, n: int) -> int:
    return ((self.__max + 1) << 1) - n
```

`value` が str の場合，文字数が bit 数以下であること，0 と 1 からなり，必ず 0 か 1 を含む文字列であることをチェックする．

```py
import re


pat = re.compile(r"[01]+")

...

elif isinstance(value, str):
    if len(value) > self.__bit:
        raise ValueError(f"length of value must be between [1, {self.__bit}].")

    if not pat.match(value):
        raise ValueError("value must be a sequence of 0 and 1.")
```

文字数が bit 数と同じで先頭が 1 の場合は負数なので補数を計算する必要がある．
4-bit int で考える．
1011 はそのまま 10 進数にすると 11 だが，先頭が 1 なので負数，つまり補数表現だと 10 進数で `x + (-x) = 0` となる何かしら 0 以上の整数 x にマイナスがついたものを表す．
`b01011 + b0yyyy = b10000` から `b0yyyy = b00101 = 5` なので 1011 は補数表現で -5 を表すことがわかる．
10 進数で考えると `5 = 2^4 - 11` なので，これにマイナスをつけると補数表現での値が得られる．
一般化して `__value = -(2**__bit - __bin)`．
実装では補助関数 `__cmpl()` を使っている．

```py
if len(value) == self.__bit and value[0] == '1':
    # MSB is 1 so we must calculate the complement
    self.__bin: int = int(value, 2)
    self.__value: int = -self.__cmpl(self.__bin)
else:
    self.__value: int = int(value, 2)
    self.__bin: int = self.__value
```

`__value`，`__bin` とも外部から参照したいが値の変更はされたくないので，変数名をマングリングしてゲッターを作る．

```py
@property
def bin(self) -> int:
    return self.__bin

@property
def value(self) -> int:
    return self.__value
```

16-bit，32-bit，64-bit はよく使うかと思って個別にオブジェクト作成用の関数を用意しといた．

```py
def Int16(value):
    return Int(value, 16)


def Int32(value):
    return Int(value, 32)


def Int64(value):
    return Int(value, 64)
```

## 文字列用のスペシャルメソッドの実装

組込み関数の `str()` や `print()` で表示される文字列を定義するため `__str__()` を実装する．
シンプルに整数値だけのほうが見やすい気がするので `__str__()` では Built-in の int と同じ表示にする．

```py
n = Int32(5)
print(n)    # 5
```
```py
def __str__(self) -> str:
    return str(self.value)
```

`__str__()` とは別に，デバッグ用に `__repr__()` を実装する．
どんなオブジェクトかがわかるように `Int(bit=32, value=5, bin=5)` のように表示する．

```py
def __repr__(self) -> str:
    return f"Int(bit={self.__bit}, value={self.__value}, bin={self.__bin})"
```


フォーマット用のスペシャルメソッドとして `__format__()` を実装する．
これを定義しておくことで，Built-in の int と同じように f 文字列や format 関数で `d` や `b` などを指定して表示することができる．

```py
n = Int32(5)
print(f"{n:05d}")   # 00005
print(f"{n:.5f}")   # 5.00000
print(f"{n:05b}")   # 00101
```

```py
def __format__(self, format_spec: str) -> str:
    t = format_spec[-1]
    if t in ('b', 'o', 'x', 'X'):
        return format(self.bin, format_spec)
    else:
        return format(self.value, format_spec)
```



## 算術演算子用のスペシャルメソッドの実装

オブジェクトに演算子を適用できるようにスペシャルメソッドを実装する．
例えば `__add__()` を定義しておくと次のように `+` が使えるようになる．
実際，`a + b` は `a.__add__(b)` を実行している．
`__add__()` の引数として自作の Int と int を扱えるようにしておけば，`Int + Int`，`Int + int` が計算できる．

```py
ope1 = Int32(1)
ope2 = Int32(2)
res = ope1 + ope2 # Int(3)

ope1 = Int32(1)
ope2 = 2
res = ope1 + 2  # Int(3)
```

補助関数 `__validate_opes()` で引数のバリデーションチェックを行う．
仕様として `+` や `-` の結果はより大きい bit 数の Int オブジェクトを返すようにした（わかりやすさ，実装のしやすさから）．

```py
def __validate_opes(self, other: Union[int, Int]) -> Tuple[Int, Int]:
    if isinstance(other, int):
        return (self, Int(other, self.__bit))
    elif isinstance(other, Int):
        greater_bit = max(self.__bit, other.bit)
        return (Int(self.value, greater_bit), Int(other.value, greater_bit))
    else:
        raise TypeError("operands must be int or Int objects")

def __apply_num_op(self, ope1: Int, ope2: Int, op: Callable[[int, int], int]) -> Int:
    res = op(ope1.value, ope2.value)
    return Int(res, ope1.bit)

...

def __add__(self, other: Union[int, Int]) -> Int:
    ope1, ope2 = self.__validate_opes(other)
    return self.__apply_num_op(ope1, ope2, operator.add)
```

`__add__()` だけだと `int + Int` が計算できないので `__radd__()` を実装する．
`a + b` を計算するとき，a に `__add__()` が定義されていない場合は b の `__radd__()` が実行される（b に `__radd__()` も定義されてない場合は TypeError になる）．
`+` は交換法則によってオペランドの順序は計算結果に影響しないので，`__radd__()` ではそのまま `__add__()` を使っている．

```py
ope1 = 1
ope2 = Int32(2)
res = ope1 + ope2 # Int(3)
```

```py
def __radd__(self, other: Union[int, Int]) -> Int:
    return self + other # self.__add__(other) と同じ
```

`+=` も使えるように `__iadd__()` を実装する．
`__riadd__()` とかはないっぽい．

```py
ope1 = Int32(1)
ope2 = Int32(2)
ope1 += ope2  # Int(3)

ope1 = Int32(1)
ope2 = 2
ope1 += ope2  # Int(3)

ope1 = 1
ope2 = Int32(2)
ope1 += ope2  # Int(3)
```

```py
def __iadd__(self, other: Union[int, Int]) -> Int:
    return self + other
```

## ビット演算子用のスペシャルメソッドの実装

算術演算子と同じように `__and__()`，`__rand__()`，`__iand__()` などを実装する．
ビット演算ではオペランドとして `value` プロパティではなく `bin` プロパティを使う．

```py
ope1 = Int(-2, 4)   # 1110
ope2 = Int(6, 4)    # 0110
res = ope1 & ope2   # 0110

ope1 = Int(-2, 4)   # 1110
ope2 = 6            # 0110
res = ope1 & ope2   # 0110

ope1 = -2           # 1110
ope2 = Int(6, 4)    # 0110
res = ope1 & ope2   # 0110


ope1 = Int(-2, 4)   # 1110
ope2 = Int(6, 4)    # 0110
ope1 &= ope2        # 0110

ope1 = Int(-2, 4)   # 1110
ope2 = 6            # 0110
ope1 &= ope2        # 0110

ope1 = -2           # 1110
ope2 = Int(6, 4)    # 0110
ope1 &= ope2        # 0110
```

```py
def __apply_bit_op(self, ope1: Int, ope2: Int, op: Callable[[int, int], int]) -> Int:
    res = op(ope1.bin, ope2.bin)
    return Int(f"{res:0{ope1.bit}b}", ope1.bit)

...

def __and__(self, other: Union[int, Int]) -> Int:
    ope1, ope2 = self.__validate_opes(other)
    return self.__apply_bit_op(ope1, ope2, operator.and_)

def __rand__(self, other: Union[int, Int]) -> Int:
    ope1, ope2 = self.__validate_opes(other)
    return self.__apply_bit_op(ope2, ope1, operator.and_)

def __iand__(self, other: Union[int, Int]) -> Int:
    return self & other
```

左シフト用のスペシャルメソッド `__lshift__()` の実装．
bit 数からはみ出た分をトランケートする処理はバイナリ表記用の整数値 `__bin` からバイナリ表記を得て，文字列として処理することで行う．
`ope1_s[shift:]` でシフト分バイナリ文字列をスライスし，`('0' * cnt_0)` で 0 埋めする．

```py
def __lshift__(self, other: Union[int, Int]) -> Int:
    ope1, ope2 = self.__validate_opes(other)
    ope1_s = f"{ope1.__bin:0{ope1.__bit}b}"
    shift = ope2.value
    cnt_0 = min(ope1.__bit, shift)
    res_s = ope1_s[shift:] + ('0' * cnt_0)
    return Int(res_s, ope1.__bit)
```

右シフトも同様．
算術右シフトとして実装する (`>>>` ではなく `>>`) ので，シフト分のパディングにはバイナリ文字列の MSB を使う (`ope1_s[0] * cnt`)．

```py
def __rshift__(self, other: Union[int, Int]) -> Int:
    ope1, ope2 = self.__validate_opes(other)
    ope1_s = f"{ope1.__bin:0{ope1.__bit}b}"
    shift = ope2.value
    cnt = min(ope1.__bit, shift)
    res_s = (ope1_s[0] * cnt) + ope1_s[:-shift]
    return Int(res_s, ope1.__bit)
```

`~` が適用できるように `__invert__()` を定義する．
ビット反転させたときのバイナリ表記の 10 進数の値は `補数 - 1` で計算できる．
4 bit int で考える．
`x = b0101` をビット反転させると `y = b1010` となり，`x + y = b1111` だから `y = b1111 - b0101`．
一方，x の補数は `b10000 - b00101 = (b01111 + b00001) - b00101`．
よって，`y = x の補数 - 1`．

```py
n = ~Int(0, 4)      # 0000
print(f"{n:04b}")   # 1111

m = ~Int(5, 4)      # 0101
print(f"{m:04b}")   # 1010
```

```py
def __invert__(self) -> Int:
    return Int(f"{self.__cmpl(self.__bin) - 1:0{self.__bit}b}", self.__bit)
```


## 比較演算子用のスペシャルメソッドの実装

Int オブジェクトどうしはプロパティ `value` の値の大小で比較する．Built-in の int と遜色なく取り扱えるようにするため，Int オブジェクトどうし以外は `value` をそのまま比較のオペランドに置く．`value` の値は int オブジェクトなので int の比較の定義がそのまま使われる．
例として `<` 用のスペシャルメソッド `__lt__()` の実装．

```py
print(Int32(-1) < Int32(5)) # True
print(Int32(-1) < 5)  # True
print(-1 < Int32(5))  # True

print(Int32(-1) < 5.0)  # True
print(-1.0 < Int32(5))  # True
```

```py
def __lt__(self, other) -> bool:
    if isinstance(other, Int):
        return self.value < other.value
    else:
        return self.value < other
```


# コード全体

ソースコードとテスト (https://github.com/e5pe0n/algorithm-training/tree/master/cracking_the_coding_interview_6th/chapter05/python/bitint)

```py
from __future__ import annotations
from typing import Callable, Union, Tuple
import re
import operator


pat = re.compile(r"[01]+")


class Int:
    def __init__(self, value: Union[int, str], bit: int):
        if bit <= 0:
            raise ValueError("bit must be greater than 0.")

        self.__bit: int = bit
        self.__max: int = (1 << (self.__bit - 1)) - 1
        self.__min: int = -self.__max - 1

        if isinstance(value, int):
            # range check
            if value < self.min:
                raise ValueError(
                    f"underflow in {self.__bit}-bit integer value. \
                        value must be between [{self.__min}, {self.__max}]")
            elif self.max < value:
                raise ValueError(
                    f"overflow in {self.bit}-bit integer value. \
                        value must be between [{self.__min}, {self.__max}]")

            if value >= 0:
                self.__value: int = value
                self.__bin: int = self.__value
            else:
                self.__value: int = value
                self.__bin: int = self.__cmpl(abs(self.__value))

        elif isinstance(value, str):
            if len(value) > self.__bit:
                raise ValueError(f"length of value must be between [1, {self.__bit}].")

            if not pat.match(value):
                raise ValueError("value must be a sequence of 0 and 1.")

            if len(value) == self.__bit and value[0] == '1':
                # MSB is 1 so we must calculate the complement
                self.__bin: int = int(value, 2)
                self.__value: int = -self.__cmpl(self.__bin)
            else:
                self.__value: int = int(value, 2)
                self.__bin: int = self.__value

        else:
            raise TypeError("value must be an int or a str object.")

    @property
    def bit(self) -> int:
        return self.__bit

    @property
    def bin(self) -> int:
        return self.__bin

    @property
    def value(self) -> int:
        return self.__value

    @property
    def max(self) -> int:
        return self.__max

    @property
    def min(self) -> int:
        return self.__min

    def __cmpl(self, n: int) -> int:
        return ((self.__max + 1) << 1) - n

    def __validate_opes(self, other: Union[int, Int]) -> Tuple[Int, Int]:
        if isinstance(other, int):
            return (self, Int(other, self.__bit))
        elif isinstance(other, Int):
            greater_bit = max(self.__bit, other.bit)
            return (Int(self.value, greater_bit), Int(other.value, greater_bit))
        else:
            raise TypeError("operands must be int or Int objects")

    def __apply_num_op(self, ope1: Int, ope2: Int, op: Callable[[int, int], int]) -> Int:
        res = op(ope1.value, ope2.value)
        return Int(res, ope1.bit)

    def __apply_bit_op(self, ope1: Int, ope2: Int, op: Callable[[int, int], int]) -> Int:
        res = op(ope1.bin, ope2.bin)
        return Int(f"{res:0{ope1.bit}b}", ope1.bit)

    def __repr__(self) -> str:
        return f"Int(bit={self.__bit}, value={self.__value}, bin={self.__bin})"

    def __str__(self) -> str:
        return str(self.value)

    def __format__(self, format_spec: str) -> str:
        t = format_spec[-1]
        if t in ('b', 'o', 'x', 'X'):
            return format(self.bin, format_spec)
        else:
            return format(self.value, format_spec)

    def __abs__(self) -> Int:
        return abs(self.__value)

    def __neg__(self) -> Int:
        return Int(-self.__value, self.__bit)

    def __add__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.add)

    def __radd__(self, other: Union[int, Int]) -> Int:
        return self + other

    def __iadd__(self, other: Union[int, Int]) -> Int:
        return self + other

    def __sub__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.sub)

    def __rsub__(self, other: Union[int, Int]) -> Int:
        return -self + other

    def __isub__(self, other: Union[int, Int]) -> Int:
        return self - other

    def __mul__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.mul)

    def __rmul__(self, other: Union[int, Int]) -> Int:
        return self * other

    def __imul__(self, other: Union[int, Int]) -> Int:
        return self * other

    def __truediv__(self, other: Union[int, Int]) -> float:
        ope1, ope2 = self.__validate_opes(other)
        return ope1.value / ope2.value

    def __rtruediv__(self, other: Union[int, Int]) -> float:
        ope1, ope2 = self.__validate_opes(other)
        return ope2.value / ope1.value

    def __itruediv__(self, other: Union[int, Int]) -> float:
        return self / other

    def __floordiv__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.floordiv)

    def __rfloordiv__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope2, ope1, operator.floordiv)

    def __ifloordiv__(self, other: Union[int, Int]) -> Int:
        return self // other

    def __mod__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.mod)

    def __rmod__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope2, ope1, operator.mod)

    def __imod__(self, other: Union[int, Int]) -> Int:
        return self % other

    def __pow__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope1, ope2, operator.pow)

    def __rpow__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_num_op(ope2, ope1, operator.pow)

    def __ipow__(self, other: Union[int, Int]) -> Int:
        return self ** other

    def __invert__(self) -> Int:
        return Int(f"{self.__cmpl(self.__bin) - 1:0{self.__bit}b}", self.__bit)

    def __and__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope1, ope2, operator.and_)

    def __rand__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope2, ope1, operator.and_)

    def __iand__(self, other: Union[int, Int]) -> Int:
        return self & other

    def __or__(self, other):
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope1, ope2, operator.or_)

    def __ror__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope2, ope1, operator.or_)

    def __ior__(self, other: Union[int, Int]) -> Int:
        return self | other

    def __xor__(self, other):
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope1, ope2, operator.xor)

    def __rxor__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return self.__apply_bit_op(ope2, ope1, operator.xor)

    def __ixor__(self, other: Union[int, Int]) -> Int:
        return self ^ other

    def __lshift__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        ope1_s = f"{ope1.__bin:0{ope1.__bit}b}"
        shift = ope2.value
        cnt_0 = min(ope1.__bit, shift)
        res_s = ope1_s[shift:] + ('0' * cnt_0)
        return Int(res_s, ope1.__bit)

    def __rlshift__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return ope2 << ope1

    def __ilshift__(self, other: Union[int, Int]) -> Int:
        return self << other

    def __rshift__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        ope1_s = f"{ope1.__bin:0{ope1.__bit}b}"
        shift = ope2.value
        cnt = min(ope1.__bit, shift)
        res_s = (ope1_s[0] * cnt) + ope1_s[:-shift]
        return Int(res_s, ope1.__bit)

    def __rrshift__(self, other: Union[int, Int]) -> Int:
        ope1, ope2 = self.__validate_opes(other)
        return ope2 >> ope1

    def __irshift__(self, other: Union[int, Int]) -> Int:
        return self >> other

    def __lt__(self, other) -> bool:
        if isinstance(other, Int):
            return self.value < other.value
        else:
            return self.value < other

    def __le__(self, other) -> bool:
        if isinstance(other, Int):
            return self.value <= other.value
        else:
            return self.value <= other

    def __gt__(self, other) -> bool:
        if isinstance(other, Int):
            return self.value > other.value
        else:
            return self.value > other

    def __ge__(self, other) -> bool:
        if isinstance(other, Int):
            return self.value >= other.value
        else:
            return self.value >= other

    def __eq__(self, other: Union[int, Int]) -> bool:
        if isinstance(other, Int):
            return self.value == other.value
        else:
            return self.value == other

    def __ne__(self, other: Union[int, Int]) -> bool:
        return not (self == other)

    def __bool__(self) -> bool:
        return bool(self.value)

    def __index__(self) -> int:
        return self.bin


def Int16(value):
    return Int(value, 16)


def Int32(value):
    return Int(value, 32)


def Int64(value):
    return Int(value, 64)
```