A15.7 Calculation and theory questions

Write each method as a function, then print the answers. - twos(bits): bits is a string of 0s and 1s of any length. Return its value as a two's complement integer: the leftmost bit is worth minus its normal place value. - float_value(mantissa, exponent): both are strings of bits. The mantissa is two's complement with the binary point just after the leftmost bit; the exponent is a two's complement integer. Return the number's value as a float. - run_fsm(transitions, state, accepting, text): transitions is a dictionary from (state, symbol) tuples to the next state, state is the start state, accepting is a set of accepting states, and text is a string of symbols. Return True if the machine ends in an accepting state. Then print exactly these six lines, using the functions for the values: 1. 11101100 = <value> using twos; 2. 01101000 x 2^0011 = <value> and 3. 10100000 x 2^1111 = <value> using float_value; 4. 1101: <result> and 5. 1001: <result>, where the result is accepted or rejected, using run_fsm with the even-number-of-1s machine above (states "even" and "odd", start "even", accepting {"even"}); 6. true rows: <n>, counting the rows where NOT (A AND B) OR C is true with three nested loops over A, B and C. The robot stays still.

# the two lines every program starts with: the commands, then the robot
from bugbot import *
connect()

def twos(bits):
    pass

The hint students can ask for: For two's complement, the leftmost bit is worth minus the place value it would normally have. The mantissa has its binary point just after the sign bit, so its value is the two's complement integer divided by the right power of two. For the FSM, look up each (state, symbol) pair in turn and check where you end.

A solution

# the two lines every program starts with: the commands, then the robot
from bugbot import *
connect()

def twos(bits):
    value = int(bits, 2)
    if bits[0] == "1":
        value -= 2 ** len(bits)
    return value

def mantissa_value(bits):
    return twos(bits) / 2 ** (len(bits) - 1)

def float_value(mantissa, exponent):
    return mantissa_value(mantissa) * 2 ** twos(exponent)

def run_fsm(transitions, state, accepting, text):
    for symbol in text:
        state = transitions[(state, symbol)]
    return state in accepting

print("11101100 =", twos("11101100"))
for m, e in [("01101000", "0011"), ("10100000", "1111")]:
    print(f"{m} x 2^{e} =", float_value(m, e))

even_ones = {("even", "0"): "even", ("even", "1"): "odd", ("odd", "0"): "odd", ("odd", "1"): "even"}
for text in ["1101", "1001"]:
    print(f"{text}:", "accepted" if run_fsm(even_ones, "even", {"even"}, text) else "rejected")

count = 0
for a in (0, 1):
    for b in (0, 1):
        for c in (0, 1):
            if (not (a and b)) or c:
                count += 1
print("true rows:", count)

Any program that meets the task's checks is marked correct in the simulator; this is one way, not the only way.