87 lines
2.8 KiB
Python
87 lines
2.8 KiB
Python
from collections import deque
|
|
|
|
|
|
class BasicRegister:
|
|
"""The BasicRegister represents a hardware register capable of manipulating multiple bits at a time.
|
|
|
|
:param deque[bool] memory: The bits stored inside the register.
|
|
"""
|
|
|
|
def __init__(self, memory: list[bool]):
|
|
"""Constructor method"""
|
|
self.memory: deque[bool] = deque(memory)
|
|
|
|
def __str__(self) -> str:
|
|
return f"Memory: {[int(value) for value in self.memory]}"
|
|
|
|
def reverse(self):
|
|
self.memory = deque([not value for value in self.memory])
|
|
|
|
def left_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
|
|
self.memory.extend([digit_to_fill] * steps_shifted)
|
|
shifted_radices: deque[bool] = deque([self.memory.popleft() for _i in range(steps_shifted)])
|
|
return shifted_radices
|
|
|
|
def right_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
|
|
self.memory.extendleft([digit_to_fill] * steps_shifted)
|
|
shifted_radices: deque[bool] = deque([self.memory.pop() for _i in range(steps_shifted)])
|
|
return shifted_radices
|
|
|
|
def adjust_size(self, s: int) -> None:
|
|
current_memory_size: int = len(self.memory)
|
|
return BasicRegister([False] * max(s - current_memory_size, 0) + list(self.memory)[-current_memory_size:])
|
|
|
|
|
|
def get_memory(variable_name: str) -> list[bool]:
|
|
"""
|
|
Reads user input to be used as a memory array.
|
|
|
|
:param str variable_name: The name to be displayed in the input line.
|
|
|
|
:return: A list of boolean values read from user.
|
|
:rtype: list[bool]
|
|
"""
|
|
while True:
|
|
input_chars: list[str] = list(input(f"Enter {variable_name}: "))
|
|
|
|
if all(character in ["0", "1"] for character in input_chars):
|
|
return [True if character == "1" else False for character in input_chars]
|
|
else:
|
|
print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
|
|
|
|
|
|
def sum(a_original: BasicRegister, b_original: BasicRegister) -> BasicRegister:
|
|
"""
|
|
Sums two registers' values.
|
|
|
|
:param BasicRegister a: First register.
|
|
:param BasicRegister b: Second register.
|
|
|
|
:return: Register containing the result.
|
|
:rtype: BasicRegister
|
|
"""
|
|
size_a = len(a_original.memory)
|
|
size_b = len(b_original.memory)
|
|
|
|
required_size = max(size_a, size_b)
|
|
|
|
if size_a != size_b:
|
|
a = a_original.adjust_size(required_size)
|
|
b = b_original.adjust_size(required_size)
|
|
else:
|
|
a = a_original
|
|
b = b_original
|
|
|
|
c = BasicRegister([False] * required_size)
|
|
|
|
carry = False
|
|
for i in range(size_a - 1, 0, -1):
|
|
current_bit_sum = a.memory[i] + b.memory[i] + carry
|
|
carry = bool(current_bit_sum & 2)
|
|
c.memory[i] = bool(current_bit_sum & 1)
|
|
|
|
final_bit_sum = a.memory[0] + b.memory[0] + carry
|
|
c.memory[0] = bool(final_bit_sum & 1)
|
|
|
|
return c
|