def main():
(options, args) = parse_args()
cardsFilePath = args[0]
tape = Tape(options.defaultValue, options.tapeSize)
maxIterations = options.maxIterations
with open(cardsFilePath, "r") as handle:
cards = json.load(handle)
currentState = "start"
iterationCount = 0
while (currentState != "halt") and (iterationCount < maxIterations):
instructions = cards[currentState][tape.read()]
tape.write(instructions["write"])
tape.move(instructions["move"])
currentState = instructions["next"]
print currentState
print tape.statusToString()
iterationCount += 1
if currentState != "halt":
print "maximum iterations exceeded!"
class TuringMachine(object):
"""
TuringMachine(machine_config, tape_content)
machine_config is a list of attributes of the Turing machine that must be like following:
position 0: List of the input alphabet
position 1: List of the tape alphabet
position 2: Symbol that represents the blank space
position 3: List of the states
position 4: The initial state
position 5: List of the final states
position 6: Number of tapes (This Turing machine simulator currently accepts only single-tape machines)
position 7 to forward: Transactions in a list format that must be like:
position 0: Currently state
position 1: Next state
position 2: The symbol of tape in current position
position 3: The New symbol of tape in current position
position 4: The indication of movement (R to right, L to left and S to stay)
tape_content is a String that represents the content on the tape at begin of Turing machine computing
"""
def __init__(self, machine_config, tape_content):
self.input_alphabet = machine_config[0]
self.tape_alphabet = machine_config[1]
self.blank_symbol = ''.join(machine_config[2])
self.states = machine_config[3]
self.init_state = ''.join(machine_config[4])
self.final_states = machine_config[5]
self.qnt_tapes = int(''.join(machine_config[6]))
self.transictions = machine_config[7:]
self.tape_content = tape_content
self.tape = Tape(self.tape_content, self.blank_symbol)
def initialize_computing(self):
"""
initialize_computing()
Initializes the Turing machine computing
"""
self.print_information()
current_state = self.init_state
queue = [self.tape]
while queue:
if current_state in self.final_states:
print(self.tape.tape_content)
print('Accept')
exit(0)
valid_transitions = self.valid_transitions(current_state)
for transition in valid_transitions:
current_state = self.aply_transaction(transition)
def validate_input(self):
"""
validate_input()
Input format validation
returns 0 if the input format is valid or one of the following for invalid:
1 if has no one input alphabet detected
2 if has no one tape alphabet detected
3 if has no one blank symbol detected
4 if has no one states detected
5 if has no one init state detected
6 if has no one final state detected
7 if the quantity of tapes is different of 1
8 if has no one transition detected
"""
if self.input_alphabet == ['']:
return 1
if self.tape_alphabet == ['']:
return 2
if self.blank_symbol == '':
return 3
if self.states == ['']:
return 4
if self.init_state == '':
return 5
if self.final_states == ['']:
return 6
if self.qnt_tapes != 1:
return 7
if self.transictions == []:
return 8
for character in list(self.tape_content)
if self.transictions == []:
return
return 0
def print_information(self):
print('Input alphabet: ', self.input_alphabet)
print('Tape alphabet: ', self.tape_alphabet)
print('Blank symbol: ', self.blank_symbol)
print('States: ', self.states)
print('Initial state: ', self.init_state)
print('Final states: ', self.final_states)
print('Quantity of tapes', self.qnt_tapes)
def aply_transaction(self, transition):
self.tape.write(transition[3])
self.tape.move(transition[4])
return transition[1]
def valid_transitions(self, state):
valid_transitions = []
for transiction in self.transictions:
if transiction[0] == state:
if self.tape.read() == transiction[2]:
valid_transitions.append(transiction)
return valid_transitions
class TuringMachine:
def __init__(self):
self.TransitionTable = []
self.tape1 = Tape()
self.tape2 = Tape()
self.tape3 = Tape()
def __str__(self):
"""Makes the machine pretty to read."""
M = str(self.tape1) + "\n" + str(self.tape2) + "\n" + str(self.tape3)
return M
def lookup_transition(self, state, in2):
"""Searches for a transition in the table, can return None."""
for tuple in self.TransitionTable:
if (tuple[0] == state and tuple[1] == in2):
return tuple
return None
def set_head_on_transition(self, transition):
"""Sets the head of the tape on the given transition."""
index = self.TransitionTable.index(transition)
index = index * 6 + 1
self.tape1.head = index
def add_transition(self, state, in2, out2, mov2, next_state):
"""Adds a new transition to the machine's transition table."""
new_tuple = (state, in2, out2, mov2, next_state)
# We check that the current state has a transition
# for the desired inputs, if it does we overwrite it
old_tuple = self.lookup_transition(state, in2)
if old_tuple:
old_tuple = new_tuple
else:
# If there is no transition for this state and inputs
# we simply add it to the machine's transition table
self.TransitionTable.append(new_tuple)
def print_transition_table(self):
"""Prints all of the transitions in the Machine."""
for tuple in self.TransitionTable:
print tuple
def tape_setup(self, word, initial_state):
"""Prepares the Machine's tapes for execution."""
# Setting up the three tapes, we cheat here and
# don't use the tape's movement and writing methods
# for simplicity and efficiency.
for transition in self.TransitionTable:
for char in transition:
self.tape1.tape.append(str(char))
self.tape1.tape.append(";")
for char in word:
self.tape2.tape.append(char)
self.tape3.move("R")
self.tape3.write(initial_state)
def execute(self, word, initial_state, halt_state, verbose = False):
"""Executes the machine, prints if the word is Accepted or Crashes."""
self.tape_setup(word, initial_state)
# Main Universal Turing Machine execution loop
# while our tape3 (the state tape) isn't pointing to halt
# we keep executing according to our transition table.
# Do note that the machine can infinite loop if its
# not programmed properly.
while self.tape3.read() != halt_state:
current_state = self.tape3.read()
input2 = self.tape2.read()
instruction = self.lookup_transition(current_state, input2)
if instruction:
output = instruction[2]
movement = instruction[3]
next_state = instruction[4]
else:
raise MachineException("CRASH")
yield self
self.tape2.write(output)
self.set_head_on_transition(instruction)
self.tape2.move(movement)
self.tape3.write(next_state)
yield self
print "ACCEPT"
