# Source code for eight_bit_computer.bitdef

```
"""
The bitdef and associated functions.
A bitdef is a string made up of ``.``\ s, ``0``\ s, and ``1``\ s.
- ``.`` means that the bit at this position could be a 0 or a 1.
- ``0`` means that the bit at this position is a 0.
- ``1`` means that the bit at this position is a 1.
When indexing into a bitdef, indexes start at 0 and begin at the right
hand side or least significant bit of the value. E.g.::
Index: 76543210
Bitdef: 010.1..1
"""
[docs]def same_length(bitdefs):
"""
Check if the passed in bitdefs are all the same length.
Args:
bitdefs list(str): Bitdefs to check length of.
Returns:
bool: True if all the bitdefs are the same length, False
otherwise
"""
all_same = True
first_length = length(bitdefs[0])
for other_bitdef in bitdefs[1:]:
other_length = length(other_bitdef)
if first_length != other_length:
all_same = False
break
return all_same
[docs]def length(bitdef):
"""
Calculate length of a bitdef.
Args:
bitdef (str): The bitdef to find the length of.
Returns:
int: The length of the bitdef.
"""
return len(bitdef)
[docs]def have_overlapping_bits(bitdefs):
"""
Check if the bitdefs have any bits set in the same position.
Example with overlap (bits at index 2 and 6 overlap):
- ``0...101.``
- ``11...1..``
Example with no overlap:
- ``11010...``
- ``......11``
Args:
bitdefs (list(str)): Bitdefs to check for overlaps.
Returns:
bool: Whether or not there were overlaps.
"""
if not same_length(bitdefs):
raise ValueError("Bitdefs are not all the same length.")
different_bits = False
for bitdef_index, bitdef in enumerate(bitdefs):
for bit_index, bit in enumerate(bitdef):
for test_bitdef in bitdefs[(bitdef_index + 1):]:
test_bit = test_bitdef[bit_index]
if bit != "." and test_bit != ".":
different_bits = True
return different_bits
[docs]def merge(bitdefs):
"""
Merge the bitdefs to a single bitdef.
Bitdefs must
- All be the same length.
- Not have any bits defined in the same position.
Args:
bitdefs (list(str)): Bitdefs to merge.
Returns:
str: The merged bitdef.
Raises:
ValueError: If the bitdefs are not all the same length or have
overlapping bits.
"""
if not same_length(bitdefs):
raise ValueError("Bitdefs are not all the same length.")
if have_overlapping_bits(bitdefs):
raise ValueError("Bitdefs have overlapping bits.")
output = ""
for index in range(length(bitdefs[0])):
for bitdef in bitdefs:
bit = bitdef[index]
if bit != ".":
output += bit
break
else:
output += "."
return output
[docs]def collapse(bitdef):
"""
Collapse undefined bits into real bits to make new bitdefs.
The undefined bits are expanded in order, from left to right, with 0
first, then 1.
For example, ``10.0.`` becomes:
- ``10000``
- ``10001``
- ``10100``
- ``10101``
Args:
bitdef(str): The bitdef to collapse.
Returns:
list(str): The list of bitdefs the original bitdef has collapsed
to.
"""
if "." in bitdef:
res = collapse(bitdef.replace(".", "0", 1))
res.extend(collapse(bitdef.replace(".", "1", 1)))
else:
res = [bitdef]
return res
[docs]def fill(bitdef, value):
"""
Fill undefined bits with a value.
For example ``1..0100.1`` becomes ``111010011`` when filled with 1s.
Args:
bitdef (str): The bitdef to fill.
value (str): The value to fill with, "0" or "1".
Returns:
str: The filled bitdef.
"""
output = ""
for bit in bitdef:
if bit == ".":
output += value
else:
output += bit
return output
[docs]def extract_bits(bitdef, end, start):
"""
Extract a region from the bitdef.
Indexes for start and end start at zero from the right or least
significant bit.
For example, if the bitdef was ``00101011`` and the extraction end
was 4 and start was 1 the result would be ``0101``::
Extracted bits: xxxx
Index: 76543210
Bitdef: 00101011
Result: 0101
Args:
bitdef (str): The bitdef to extract bits from.
end (int): Index of the leftmost bit of the portion to extract.
start (int): Index of the rightmost bit of the portion to
extract.
Returns:
str: The extracted portion of the bitdef.
Raises:
ValueError: If:
- Extraction region is larger than bitdef.
- Extraction end index is before extraction start index.
- Extraction start index is less than 0.
"""
bitdef_length = length(bitdef)
if end > bitdef_length:
raise ValueError("Extraction region is larger than bitdef.")
if end < start:
raise ValueError(
"Extraction end index is before extraction start index."
)
if start < 0:
raise ValueError("Extraction start index is less than 0.")
if bitdef_length == 0:
return bitdef
reverse_end = reverse_index(end, bitdef_length)
reverse_start = reverse_index(start, bitdef_length)
return bitdef[reverse_end:reverse_start + 1]
[docs]def remove_whitespace(input_string):
"""
Remove the whitespace from a string.
Args:
input_string (str): The string to remove whitespace from.
Returns:
str: The string with the whitespace removed.
"""
return "".join(input_string.strip().split())
[docs]def reverse_index(index, length):
"""
Reverse the passed in index as if the index direction was flipped.
Taking the string "hello" as an example the regular indexes for
each letter are::
01234
hello
Reversing the indexes yields::
43210
hello
This allows easily indexing into a bitdef on bitdef indexing terms.
Args:
index (int): The index position to reverse.
length (int): The length of the array being indexed into.
Returns:
int: The reversed index.
"""
return length - index - 1
```