# eight_bit_computer.bitdef module¶

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
```
`eight_bit_computer.bitdef.``same_length`(bitdefs)[source]

Check if the passed in bitdefs are all the same length.

Parameters: list (bitdefs) – Bitdefs to check length of. True if all the bitdefs are the same length, False otherwise bool
`eight_bit_computer.bitdef.``length`(bitdef)[source]

Calculate length of a bitdef.

Parameters: bitdef (str) – The bitdef to find the length of. The length of the bitdef. int
`eight_bit_computer.bitdef.``have_overlapping_bits`(bitdefs)[source]

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`
Parameters: bitdefs (list(str)) – Bitdefs to check for overlaps. Whether or not there were overlaps. bool
`eight_bit_computer.bitdef.``merge`(bitdefs)[source]

Merge the bitdefs to a single bitdef.

Bitdefs must

• All be the same length.
• Not have any bits defined in the same position.
Parameters: bitdefs (list(str)) – Bitdefs to merge. The merged bitdef. str `ValueError` – If the bitdefs are not all the same length or have overlapping bits.
`eight_bit_computer.bitdef.``collapse`(bitdef)[source]

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`
Parameters: bitdef (str) – The bitdef to collapse. The list of bitdefs the original bitdef has collapsed to. list(str)
`eight_bit_computer.bitdef.``fill`(bitdef, value)[source]

Fill undefined bits with a value.

For example `1..0100.1` becomes `111010011` when filled with 1s.

Parameters: bitdef (str) – The bitdef to fill. value (str) – The value to fill with, “0” or “1”. The filled bitdef. str
`eight_bit_computer.bitdef.``extract_bits`(bitdef, end, start)[source]

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
```
Parameters: 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. The extracted portion of the bitdef. str `ValueError` – If: Extraction region is larger than bitdef. Extraction end index is before extraction start index. Extraction start index is less than 0.
`eight_bit_computer.bitdef.``remove_whitespace`(input_string)[source]

Remove the whitespace from a string.

Parameters: input_string (str) – The string to remove whitespace from. The string with the whitespace removed. str
`eight_bit_computer.bitdef.``reverse_index`(index, length)[source]

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.

Parameters: index (int) – The index position to reverse. length (int) – The length of the array being indexed into. The reversed index. int