185 lines
6.1 KiB
Python
185 lines
6.1 KiB
Python
from collections import deque
|
|
from typing_extensions import Self
|
|
|
|
|
|
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]):
|
|
self.memory: deque[bool] = deque(memory)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"Memory: {[int(value) for value in self.memory]}"
|
|
|
|
def __str__(self) -> str:
|
|
return f"Memory: {[int(value) for value in self.memory]}"
|
|
|
|
def __len__(self) -> int:
|
|
return len(self.memory)
|
|
|
|
def adjusted_by_size(self, resulting_size: int) -> Self:
|
|
"""
|
|
Adjusts a register to a given size.
|
|
|
|
:param int resulting_size: The size of the resulting register.
|
|
|
|
:return: A register of a specified size.
|
|
:rtype: BasicRegister
|
|
"""
|
|
current_memory_size: int = len(self.memory)
|
|
return BasicRegister(
|
|
[False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:]
|
|
)
|
|
|
|
def reverse(self):
|
|
"""
|
|
Performs a logical negation on the register.
|
|
"""
|
|
self.memory = deque([not value for value in self.memory])
|
|
|
|
def left_shift(self, shift_in_value: bool = False, bits_shifted: int = 1) -> deque[bool]:
|
|
"""
|
|
Shifts the register to the left by a specified number of steps
|
|
|
|
:param bool shift_in_value: The value that shifts inside the freed space.
|
|
:param int bits_shifted: The number of bits by which the register is shifted.
|
|
|
|
:return: The bits shifted outside the register.
|
|
:rtype: deque[bool]
|
|
"""
|
|
self.memory.extend([shift_in_value] * bits_shifted)
|
|
shifted_bits: deque[bool] = deque([self.memory.popleft() for _i in range(bits_shifted)])
|
|
return shifted_bits
|
|
|
|
def right_shift(self, shift_in_value: bool = False, bits_shifted: int = 1) -> deque[bool]:
|
|
"""
|
|
Shifts the register to the right by a specified number of steps
|
|
|
|
:param bool shift_in_value: The value that shifts inside the freed space.
|
|
:param int bits_shifted: The number of bits by which the register is shifted.
|
|
|
|
:return: The bits shifted outside the register.
|
|
:rtype: deque[bool]
|
|
"""
|
|
self.memory.extendleft([shift_in_value] * bits_shifted)
|
|
shifted_bits: deque[bool] = deque([self.memory.pop() for _i in range(bits_shifted)])
|
|
return shifted_bits
|
|
|
|
|
|
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 binary_sum_with_carry(first_term: BasicRegister, second_term: BasicRegister) -> tuple[BasicRegister, int]:
|
|
"""
|
|
Sums two registers' values and keeps the carry-out.
|
|
|
|
:param BasicRegister first_term: First register.
|
|
:param BasicRegister second_term: Second register.
|
|
|
|
:return: Register containing the sum and the carry-out bit.
|
|
:rtype: tuple[BasicRegister, int]
|
|
"""
|
|
result_term = BasicRegister([False] * len(first_term))
|
|
|
|
carry = False
|
|
for i in range(len(first_term) - 1, 0, -1):
|
|
current_bit_sum = first_term.memory[i] + second_term.memory[i] + carry
|
|
carry = bool(current_bit_sum & 2)
|
|
result_term.memory[i] = bool(current_bit_sum & 1)
|
|
|
|
final_bit_sum = first_term.memory[0] + second_term.memory[0] + carry
|
|
final_carry = bool(final_bit_sum & 2)
|
|
result_term.memory[0] = bool(final_bit_sum & 1)
|
|
|
|
return result_term, final_carry
|
|
|
|
|
|
def binary_sum(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
|
|
"""
|
|
Sums two terms containing binary numbers.
|
|
|
|
:param BasicRegister first_term: First register to add.
|
|
:param BasicRegister second_term: Second register to add.
|
|
|
|
:return: Register containing the sum.
|
|
:rtype: BasicRegister
|
|
"""
|
|
return binary_sum_with_carry(first_term, second_term)[0]
|
|
|
|
|
|
def binary_subtraction(minuend: BasicRegister, subtrahend: BasicRegister) -> BasicRegister:
|
|
"""
|
|
Subtracts the second term from the first in binary using ones' complement.
|
|
|
|
:param BasicRegister minuend: Register to subtract from.
|
|
:param BasicRegister subtrahend: Register to subtract by.
|
|
|
|
:return: Register containing the difference.
|
|
:rtype: BasicRegister
|
|
"""
|
|
subtrahend.reverse()
|
|
|
|
difference: BasicRegister
|
|
final_carry: bool
|
|
difference, final_carry = binary_sum_with_carry(minuend, subtrahend)
|
|
|
|
if final_carry:
|
|
return binary_sum(difference, BasicRegister([False] * (len(difference) - 1) + [True]))
|
|
else:
|
|
difference.reverse()
|
|
return difference
|
|
|
|
|
|
# def align_registers(first_register: BasicRegister, second_register: BasicRegister) \
|
|
# -> tuple[BasicRegister, BasicRegister]:
|
|
# """
|
|
# Aligns two registers by the length of the bigger one.
|
|
#
|
|
# :param BasicRegister first_register:
|
|
# :param BasicRegister second_register:
|
|
#
|
|
# :return:
|
|
# :rtype: tuple[BasicRegister, BasicRegister]
|
|
# """
|
|
# first_size = len(first_register)
|
|
# second_size = len(second_register)
|
|
#
|
|
# required_size = max(first_size, second_size)
|
|
#
|
|
# if first_size != second_size:
|
|
# return first_register.adjusted_by_size(required_size), second_register.adjusted_by_size(required_size)
|
|
# else:
|
|
# return first_register, second_register
|
|
|
|
|
|
def align_registers(*args: BasicRegister) -> tuple[BasicRegister, ...]:
|
|
"""
|
|
Aligns registers by the length of the bigger one.
|
|
|
|
:param args: Basic registers to align.
|
|
|
|
:return: Aligned registers.
|
|
:rtype: tuple[BasicRegister, ...]
|
|
"""
|
|
required_size: int = max(map(len, args))
|
|
return tuple(reg.adjusted_by_size(required_size) for reg in args)
|