def findKthNumber(self, n, k):
"""
:type n: int
:type k: int
:rtype: int
"""
if n>1 and k>1:
t = Tree(1, compare=compare)
count = 1
tmax = 1
for l in range(2,n+1):
if count < k:
t.addNode(l)
tmax = t.find_max()
count += 1
# print("# added %i and now max = %i" % (l, tmax))
else: # count > k
if int(str(l)[0])
if compare(l, tmax):
t.addNode(l)
t, tmax = t.del_max()
# print("# added %i and removed max. current max = %i" % (l, tmax))
else:
continue
# t.printTree()
return t.find_max()
else:
if n==1 or k==1:
return 1
def list2Tree(lst):
if len(lst) == 0:
return None
else:
root = Tree(lst[0])
if len(lst) > 1:
for i in lst[1:]:
root.addNode(i)
return root
def solver(self, adjLists):
solutions = []
# Get the set of all words in the corpus. Set is more performant than list here.
corpus = set(w.lower() for w in nltk.corpus.words.words())
# load words into tree. Don't load anything shorter than 3 or longer than
# current letter set plus 1(ie 4x4 board would be 16 characters w/o QU or 17 with)
# max because we can only visit that letter once)
tree = Tree()
for w in corpus:
if len(w) < 3:
continue
if len(w) > (self.boardSize * self.boardSize) + 1:
continue
first = Node(w[0])
subsequent = w[1:]
parent = tree.addNode(first)
last = None
for c in subsequent:
child = tree.addNode(Node(c), parent)
parent = child
last = child
# mark the end of a word for later
if last is not None:
last.endsWord = True
# walk the word tree with the letters on the board,
# building up strings by adjacencies.
visited = []
sols = []
#pos in self.currentLetters: # board in order
# Not working yet.
'''
for idx, val in np.ndenumerate(self.currentLetters):
#idx position
#val letter
self.findStrings(idx, tree.root.children[0], visited)
'''
# just returning something for now so I can pass them to the front end
return ['solution1', 'solution2', 'solution3']
class TreeBuilder:
'''
Builds a tree from a given list of values
'''
def __init__(self):
self.tree = Tree()
self.values = []
def setValues(self, newValues: List[NUM]):
self.values = newValues
self.tree = Tree() # need to rebuild tree
def build(self):
for value in self.values:
newNode = Node()
newNode.setValue(value)
self.tree.addNode(newNode)
def main(arguments):
if len(arguments) < 3:
print 'The argument 1 should be a filename to pickle tree contents into.'
print 'The argument 2 should be the directory where the images can be found.'
else:
imagenet_tree = Tree('Image Net Tree')
# Add our selected parent nodes
imagenet_tree.addNode('n00017222'); # Plant flora root node
imagenet_tree.addNode('n13083586','n00017222'); # Vascular root
# Add nodes which we need to build the tree for to a dictionary form node:parent
node_dictionary = {
'n13134302':'n13083586', # Vascular child: Bulbous
'n13121544':'n13083586', # Vascular child: Aquatic
'n13121104':'n13083586', # Vascular child: Desert
'n13103136':'n13083586', # Vascular child: Woody plants
'n13100677':'n13083586', # Vascular child: Vines
'n13085113':'n13083586', # Vascular child: Weed
'n13084184':'n13083586', # Vascular child: Succulent
'n12205694':'n13083586', # Vascular child: Herb
'n11552386':'n13083586', # Vascular child: Spermatophyte
'n11545524':'n13083586', # Vascular child: Pteridophyte
'n13100156':'n00017222', # House plant root
'n13083023':'n00017222', # Poisonous root
}
for node in node_dictionary:
print 'Processing %s' % (node)
number_of_images = 0
if (os.path.isdir(arguments[2]+'/'+node)):
number_of_images = len([name for name in os.listdir(arguments[2]+'/'+node)
if os.path.isfile(arguments[2]+'/'+node+'/'+name) and name[-5:] == '.JPEG'])
imagenet_tree.addNode(node,node_dictionary[node],number_of_images)
print 'Images found for %s:%i' % (node,number_of_images)
addAllNodes(imagenet_tree,node,arguments[2])
pickled_file = open(arguments[1],'wb')
pickle.dump(imagenet_tree,pickled_file)
def main(arguments):
if len(arguments) < 3:
print 'The argument 1 should be a filename to pickle tree contents into.'
print 'The argument 2 should be the directory where the images can be found.'
else:
imagenet_tree = Tree('Image Net Tree')
# Add our selected parent nodes
imagenet_tree.addNode('n00017222')
# Plant flora root node
imagenet_tree.addNode('n13083586', 'n00017222')
# Vascular root
# Add nodes which we need to build the tree for to a dictionary form node:parent
node_dictionary = {
'n13134302': 'n13083586', # Vascular child: Bulbous
'n13121544': 'n13083586', # Vascular child: Aquatic
'n13121104': 'n13083586', # Vascular child: Desert
'n13103136': 'n13083586', # Vascular child: Woody plants
'n13100677': 'n13083586', # Vascular child: Vines
'n13085113': 'n13083586', # Vascular child: Weed
'n13084184': 'n13083586', # Vascular child: Succulent
'n12205694': 'n13083586', # Vascular child: Herb
'n11552386': 'n13083586', # Vascular child: Spermatophyte
'n11545524': 'n13083586', # Vascular child: Pteridophyte
'n13100156': 'n00017222', # House plant root
'n13083023': 'n00017222', # Poisonous root
}
for node in node_dictionary:
print 'Processing %s' % (node)
number_of_images = 0
if (os.path.isdir(arguments[2] + '/' + node)):
number_of_images = len([
name for name in os.listdir(arguments[2] + '/' + node)
if os.path.isfile(arguments[2] + '/' + node + '/' +
name) and name[-5:] == '.JPEG'
])
imagenet_tree.addNode(node, node_dictionary[node],
number_of_images)
print 'Images found for %s:%i' % (node, number_of_images)
addAllNodes(imagenet_tree, node, arguments[2])
pickled_file = open(arguments[1], 'wb')
pickle.dump(imagenet_tree, pickled_file)
import numpy as np
from tree import Tree
from lexicographical import compare
np.random.seed(1234)
lst = np.random.randint(0, 50, 10)
print(lst)
t = Tree(lst[0])
for l in lst[1:]:
t.addNode(l)
t.printTree()
t = t.del_max()
print("head = ", t.val)
if t.right is not None:
print("head.right = ", t.right.val)
t.printTree()
for _ in range(5):
print("remove..")
t = t.del_max()
t.printTree()
def geraGrafo(id, id_pai, estado_inicial, estado_final, restricoes, pesos, personagens, num_ocupantes_barco, dicionario_heuristica, problema):
def prob_1():
root.destroy()
ROOT = 0
# Fazendeiro, alface, bode, lobo:
dicionario_heuristica = {
'A B F L|': 22,
'A L|B F': 18,
'A F L|B': 17,
'L|A B F': 14,
'A|B F L': 12,
'B F L|A': 10,
'A B F|L': 8,
'B|A F L': 5,
'B F|A L': 4,
'|A B F L': 0
}
# comecamos com id(atual) = id)pai = ROOT
id = ROOT
id_pai = ROOT
estado_inicial = "A B F L|"
estado_final = "|A B F L"
# vetor com as restricoes do problema
restricoes = ["A,B", "L,B"] # Vetor de restrições
# vetor com os pesos referentes ao transporte de cada personagem
pesos = {'F': 1, 'A': 2, 'B': 3, 'L': 4}
# vetor de personagens
personagens = ['F', 'A', 'B', 'L']
# capacidade do barco
num_ocupantes_barco = 2
geraGrafo(id, id_pai, estado_inicial, estado_final, restricoes, pesos, personagens, num_ocupantes_barco,
dicionario_heuristica, 1)
def prob_2():
root.destroy()
ROOT = 0
# Cachorro Fazendeiro Gato Queijo Rato:
dicionario_heuristica = {
'C F G Q R|': 17, # 0
'G Q|C F R': 8, # 1
'C R|F G Q': 10, # 2
'C Q|F G R': 17, # 3
'F G Q|C R': 7, # 4
'C F G Q|R': 18, # 5, 10
'F G Q R|C': 12, # 6
'C F R|G Q': 9, # 7
'C F G R|Q': 19, # 8
'C F Q R|G': 19, # 9, 11
'Q|C F G R': 12, # 12, 15, 19, 28, 30, 34
'G|C F Q R': 10, # 13, 16, 20, 25, 31
'|C F G Q R': 0, # 14, 23
'C|F G Q R': 13, # 17, 22, 26, 29, 32, 35
'R|C F G Q': 13, # 18, 21, 24, 27, 33
'F G R|C Q': 8 # 36, 37, 38, 39, 40, 41, 42, 43....
}
# comecamos com id(atual) = id)pai = ROOT
id = ROOT
id_pai = ROOT
estado_inicial = "C F G Q R|"
estado_final = "|C F G Q R"
# vetor com as restricoes do problema
restricoes = ["C,G", "G,R", "R,Q"] # Vetor de restrições
# vetor com os pesos referentes ao transporte de cada personagem
pesos = {'F': 1, 'Q': 2, 'R': 3, 'G': 4, 'C': 5}
# vetor de personagens
personagens = ['F', 'C', 'G', 'R', 'Q']
# capacidade do barco
num_ocupantes_barco = 3
geraGrafo(id, id_pai, estado_inicial, estado_final, restricoes, pesos, personagens, num_ocupantes_barco,
dicionario_heuristica, 2)
# criando objeto arvore
arvore = Tree()
# adicionando no raiz
arvore.addNode(estado_inicial, 0)
# Gerando os conjuntos de restricoes
global restr_sep
restr_sep = [x.split(',') for x in restricoes]
def valida_margem(margem):
# Se o fazendeiro está na margem, nao tem problema
if not ('F' in margem):
combinacoes = list(itertools.combinations(margem, 2))
for i in combinacoes: # passando por todas as combinacoes, 2 a 2, dos elementos da margem
for j in restr_sep: # passando pelas restricoes
if (set(i) == set(
j)): # comparando se as combinacoes batem com alguma das restricoes -> movimento invalido
return False
return True
# verifica se um no ja existe
def ja_existe(msg, id_pai_atual):
# separa a msg no |(que se refere ao rio). Assim, ficamos com os vetores referentes as margens esquerda e direita
msg_arr = msg.split('|')
msg_arr_esq = msg_arr[0].split() # elementos presentes na margem esquerda
msg_arr_dir = msg_arr[1].split() # elementos presentes na margem direita
# iterando sobre os nos presentes na arvore para verificar se existe um no que tenha como dado o mesmo valor presente em msg
for i in arvore.getAllNodes():
dado_no = i.getData().split('|') # divide a mensagem em margem direita e esquerda por meio do sinal |
dado_no_esq = dado_no[0].split() # elementos referentes a margem esquerda
dado_no_dir = dado_no[1].split() # elementos referentes a margem esquerda
if ((sorted(dado_no_esq) == sorted(msg_arr_esq)) or (sorted(dado_no_dir) == sorted(
msg_arr_dir))): # trabalha com os elementos ordenados JA que, para o problema, A B seja igual a B A
if (i.getId() <= ((id_pai_atual) - 1)) or (
i.getId() == 0): # testa se o id do no igual é o inicial ou se esta pelo menos 1 valor atras do atual
return True
return False # o no ainda nao existe, ou sua criacao nao resulta em um loop
def calcula_custo(estado_pai, estado_filho):
custo = 0
quem_viajou = []
margens_pai = estado_pai.split('|')
margem_dir_pai = margens_pai[0].split()
margem_esq_pai = margens_pai[1].split()
margens_filho = estado_filho.split('|')
margem_dir_filho = margens_filho[0].split()
margem_esq_filho = margens_filho[1].split()
if ('F' in margem_dir_pai):
quem_viajou = list(set(margem_dir_pai) - set(margem_dir_pai).intersection(set(margem_dir_filho)))
else:
quem_viajou = list(set(margem_esq_pai) - set(margem_esq_pai).intersection(set(margem_esq_filho)))
for ator in personagens:
custo = custo + (ator in quem_viajou) * pesos[ator]
return custo
arestas = []
custos_arestas = dict()
custo_transicao = 0
# enquanto o id do no atual nao ultrapassar o numero de nos da arvore(caso em que a geracao da arvore deve encerrar, pois o ultimo no foi atingido e nao gerou nenhum filho)
while (id_pai < len(arvore.getAllNodes())):
num_gerados = 0 # ainda nao gerou nenhum filho
# recupera o no atual
no = arvore.getNode(id_pai)
# recupera a informacao presente no nó, referente à modelagem das margens esquerda e direita
margens = no.getData().split('|')
margem_esq = margens[0].split()
margem_dir = margens[1].split()
# se o fazendeiro esta na margem esquerda, o barco saira dela
if ('F' in margem_esq):
for k in range(num_ocupantes_barco):
# gera as combinacoes, 1 a 1 e 2 a 2, dos elementos da margem esquerda para que ocupem o barco, nao excedendo sua capacidade
combinacoes = list(itertools.combinations(margem_esq, k + 1))
for barco in combinacoes:
# se o fazendeiro esta no barco, a configuracao do barco eh valida, ja que soh o fazendeiro pode guia-lo
if ('F' in barco):
# a margem esquerda apos a saida dos ocupantes do barco
margem_esq_resultante = list(set(margem_esq) - set(barco))
# testa se a configuracao da margem, caso os ocupantes do barco zarpem, continua valida segundo as restricoes do problema
if (valida_margem(margem_esq_resultante)):
# constroi a mensagem referente ao estado do no, na forma: margem_esquerda|margem_direita
if (len(margem_esq_resultante)):
margem_esq_resultante = sorted(margem_esq_resultante)
msg = margem_esq_resultante[0]
for i in range(1, len(margem_esq_resultante)):
msg = msg + ' ' + margem_esq_resultante[i]
else:
msg = ''
msg = msg + '|'
margem_dir_resultante = list(set(margem_dir).union(
set(barco))) # a margem direita apos a chegada dos ocupantes do barco
if (len(margem_dir_resultante)):
margem_dir_resultante = sorted(margem_dir_resultante)
msg = msg + margem_dir_resultante[0]
for i in range(1, len(margem_dir_resultante)):
msg = msg + ' ' + margem_dir_resultante[i]
else:
msg = msg + ''
if (not ja_existe(msg, id_pai)): # se o no ainda nao existe
id = id + 1
aresta = (arvore.getNode(id_pai).getData(), msg)
arestas.append(aresta)
custo_transicao = calcula_custo(arvore.getNode(id_pai).getData(), msg)
custos_arestas[aresta] = custo_transicao
arvore.addNode(msg, id, custo_transicao, id_pai) # cria um novo no
else:
# se o fazendeiro esta na margem esquerda, o barco saira dela
if ('F' in margem_dir):
for k in range(num_ocupantes_barco):
# gera as combinacoes, 1 a 1 e 2 a 2, dos elementos da margem esquerda para que ocupem o barco, nao excedendo sua capacidade
combinacoes = list(itertools.combinations(margem_dir, k + 1))
for barco in combinacoes:
# se o fazendeiro esta no barco, a configuracao do barco eh valida, ja que soh o fazendeiro pode guia-lo
if ('F' in barco):
# a margem direita apos a saida dos ocupantes do barco
margem_dir_resultante = list(set(margem_dir) - set(barco))
# testa se a configuracao da margem, caso os ocupantes do barco zarpem, continua valida segundo as restricoes do problema
if (valida_margem(margem_dir_resultante)):
# a margem esquerda apos a chegada dos ocupantes do barco
margem_esq_resultante = list(set(margem_esq).union(set(barco)))
# constroi a mensagem referente ao estado do no, na forma: margem_esquerda|margem_direita
if (len(margem_esq_resultante)):
margem_esq_resultante = sorted(margem_esq_resultante)
msg = margem_esq_resultante[0]
for i in range(1, len(margem_esq_resultante)):
msg = msg + ' ' + margem_esq_resultante[i]
else:
msg = ''
msg = msg + '|'
if (len(margem_dir_resultante)):
margem_dir_resultante = sorted(margem_dir_resultante)
msg = msg + margem_dir_resultante[0]
for i in range(1, len(margem_dir_resultante)):
msg = msg + ' ' + margem_dir_resultante[i]
else:
msg = msg + ''
if (not ja_existe(msg, id_pai)): # se o no ainda nao existe
id = id + 1
aresta = (arvore.getNode(id_pai).getData(), msg)
arestas.append(aresta)
custo_transicao = calcula_custo(arvore.getNode(id_pai).getData(), msg)
custos_arestas[aresta] = custo_transicao
arvore.addNode(msg, id, custo_transicao, id_pai) # cria um novo no
# vai para o proximo no
id_pai = id_pai + 1
def converteDicToList(dicionario):
num_nos = len(arvore.getAllNodes())
lista = np.zeros(num_nos)
for no in arvore.getAllNodes():
for chave in dicionario:
if chave == no.getData():
lista[no.getId()] = dicionario[chave]
break
return lista
for i in arvore.getAllNodes():
print(i.getData())
# exibe o grafo gerado
'''f = open("grafo.txt","w+")
print("\n\nPrintando grafo")
for i in arvore.getAllNodes():
f.write("-----\n")
print("-----")
f.write("[" + str(i.getId()) + "]\n")
print("[", i.getId(),"]")
if(not i.getParent() is None):
f.write("Meu papai eh: " + str(i.getParent()) + "\n")
print("Meu papai eh: " + str(i.getParent()))
else:
f.write("Nao tenho papai :(\n")
print("Nao tenho papai :(")
f.write("Minha informacao eh: " + str(i.getData()) + "\n")
print("Minha informacao eh: ", i.getData())
f.write("Meus filhinhos sao: " + str(i.getChildren()) + "\n")
print("Meus filhinhos sao: ", i.getChildren())
f.write("Os peso pra ir nos meus filhinhos são: " + str(i.getPesosParaOsFilhos()) + "\n\n")
print("Os peso pra ir nos meus filhinhos são: ", i.getPesosParaOsFilhos())
f.close()'''
caminho_busca_largura = arvore.buscaLargura(arvore)
vet_dist_estado_final = converteDicToList(dicionario_heuristica)
caminho_busca_a_estrela = arvore.busca_A_estrela(arvore, vet_dist_estado_final)
# Parte de exibição **********************************************
nos = [v.getData() for v in arvore.getAllNodes()]
exibeGrafo(nos, arestas, custos_arestas, personagens, estado_inicial, estado_final, caminho_busca_largura)
# exibir em janela
root = Tk()
root.geometry("1000x620+0+0")
if(problema == 1):
root.title("IA - Travessia do rio: Fazendeiro, Lobo, Bode e Alface")
else:
if (problema == 2):
root.title("IA - Travessia do rio: Fazendeiro, Cachorro, Gato, Rato e Queijo")
# Frame superior ********************************
FImgs = Frame(root, width=700, height=500, bd=1, relief=SUNKEN)
FImgs.grid(row=0, padx=10, pady=15)
imgEntrada = PhotoImage(file="grafo.png")
labelImgEntrada = Label(FImgs, image=imgEntrada)
labelImgEntrada.pack(side=LEFT, padx=15, pady=15)
FLegenda = Frame(root, width=700, height=60, bd=1, relief=SUNKEN)
FLegenda.grid(row=1)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT)
greenCircle = canvas.create_oval(10, 10, 40, 40, fill="green")
Label(FLegenda, text="Caminho resultante").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
purpleCircle = canvas.create_oval(10, 10, 40, 40, fill="purple")
Label(FLegenda, text="Estado inicial").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
yellowCircle = canvas.create_oval(10, 10, 40, 40, fill="yellow")
Label(FLegenda, text="Estado final").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
blueCircle = canvas.create_oval(10, 10, 40, 40, fill="blue")
Label(FLegenda, text="Estado do grafo").pack(side=LEFT)
FResultadoBuscaLargura = Frame(root, width=300, height=500, bd=1, relief=SUNKEN)
FResultadoBuscaLargura.grid(row=0, column=1)
Label(FResultadoBuscaLargura, text='Resultado Busca em Largura', justify=CENTER).grid(row=0, pady=10, sticky=W)
i = 1
for estado in caminho_busca_largura:
Label(FResultadoBuscaLargura, text=estado, justify=CENTER).grid(row=i, pady=10)
i += 1
FResultadoBuscaAEstrela = Frame(root, width=300, height=500, bd=1, relief=SUNKEN)
FResultadoBuscaAEstrela.grid(row=0, column=2, padx=15)
Label(FResultadoBuscaAEstrela, text='Resultado Busca A*', justify=CENTER).grid(row=0, pady=10, sticky=W)
if(problema == 1):
botao = Button(root, text="Ir para o problema 2", command=prob_2, width=25, height=3)
botao.grid(row=1, column=1, columnspan=2)
else:
if (problema == 2):
botao = Button(root, text="Ir para o problema 1", command=prob_1, width=25, height=3)
botao.grid(row=1, column=1, columnspan=2)
i = 1
for no in caminho_busca_a_estrela:
Label(FResultadoBuscaAEstrela, text=no.getData(), justify=CENTER).grid(row=i, pady=10)
i += 1
root.mainloop()
class TicTacToe(object):
def __init__(self):
self.tree = None
self.xplayer = False #True if human player
self.oplayer = False #True if human player
self.gameover = False
self.xturn = True #False if oturn
self.template = StateTemplate([0, 1, 2, 3, 4, 5, 6, 7, 8])
self.startState = [-1, -1, -1, -1, -1, -1, -1, -1, -1]
def setupTree(self):
'''Set up the full tree which shows all of the game states'''
self.tree = Tree()
self.tree.root.data = GameState(self.startState)
node = self.tree.root
while node is not None:
if -1 in node.data.state:
nodestate = deepcopy(node.data.state)
index = nodestate.index(-1)
node.data.state[index] = -2
node = self.tree.addNode(node)
#node = self.tree.findNode(nodeid)
if len([k for k in nodestate if k == -1 or k == -2]) % 2:
#if len(node.id) % 2 == 0:
nodestate[index] = 'X'
else:
nodestate[index] = 'O'
for i in range(len(nodestate)):
if nodestate[i] == -2:
nodestate[i] = -1
node.data = GameState(nodestate)
#node.depth = len(node.id)-1 #depth is 0-based
else:
node = node.parent
self.tree.prune(self.tree.root,
filters()) #prune the tree with the filters
def checkEndGame(self):
'''Return true if the current node has no children'''
if len(self.tree.root.children) == 0:
return True
return False
def humanFirstTurn(self):
return int(raw_input("Enter an 'X' at location: (0-8) "))
def humanTurn(self, symbol):
'''Gets called when it is a humans turn. symbol is either "X" or "O"'''
i = int(raw_input("Enter an '" + symbol + "' at location: (0-8) "))
data = self.tree.root.data.copy()
if not data.setData(symbol, i):
print("Cannot place '" + symbol + "' there. Try again")
self.humanTurn(symbol)
else:
node = self.tree.find(data)
self.tree.setRoot(node.id)
#def aiTurn(self, symbol, index):
# '''The ai at this point has chosen the best path as given by the index'''
# data = self.tree.root.data.copy() #get a copy of root GameState
# #data.setData(symbol, index)
# node = self.tree.find(data)
# self.tree.setRoot(node.id)
def makeMoveAI(self, index):
node = self.tree.root.children[index]
self.tree.setRoot(node.id)
from tree import Tree
#Tree tests complete
t = Tree(3)
print(t)
a = t.addNode(0, 4)
b = t.addNode(0, 5)
c = t.addNode(a, 6)
d = t.addNode(a, 7)
e = t.addNode(d, 8)
print(t)
print("Path to e:")
p = t.pathToNode(e)
for i in p:
print("\t", t.getData(i))
print("Path to c")
p = t.pathToNode(c)
for i in p:
print("\t", t.getData(i))
print("Leaves:")
l = t.leaves()
for i in l:
print(t.getData(i))
import numpy as np
from tree import Tree
if __name__ == '__main__':
root = None
np.random.seed(1234)
for i in np.random.randint(0, 100, 10):
print(i)
if root is None:
root = Tree(i)
else:
root.addNode(i)
print("Printing the whole tree: ")
root.printTree()
print("Printing the tree with level")
root.printTreeLevel(0)
print("Printing the tree by level")
root.printTreeByLevel(root)
# single node tree:
t = Tree(0)
t.printTreeByLevel(t)
def inicializa_main_cinco_itens():
ROOT = 0
#Cachorro Fazendeiro Gato Queijo Rato:
dicionario_heuristica_5_itens = {
'C F G Q R|': 17, #0
'G Q|C F R': 8, #1
'C R|F G Q': 10, #2
'C Q|F G R': 17, #3
'F G Q|C R': 7, #4
'C F G Q|R': 18, #5, 10
'F G Q R|C': 12, #6
'C F R|G Q': 9, #7
'C F G R|Q': 19, #8
'C F Q R|G': 19, #9, 11
'Q|C F G R': 12, #12, 15, 19, 28, 30, 34
'G|C F Q R': 10, #13, 16, 20, 25, 31
'|C F G Q R': 0, #14, 23
'C|F G Q R': 13, #17, 22, 26, 29, 32, 35
'R|C F G Q': 13, #18, 21, 24, 27, 33
'F G R|C Q': 8 #36, 37, 38, 39, 40, 41, 42, 43....
}
#comecamos com id(atual) = id)pai = ROOT
id = ROOT
id_pai = ROOT
#criando objeto arvore
arvore = Tree()
#adicionando no raiz
arvore.addNode("C F G Q R|", 0)
#vetor com as restricoes do problema
restricoes = ["C,G", "G,R", "R,Q"] #Vetor de restrições
#vetor com os pesos referentes ao transporte de cada personagem
pesos = {'F': 1, 'Q': 2, 'R': 3, 'G': 4, 'C': 5}
#vetor de personagens
global personagens
personagens = ['F', 'C', 'G', 'R', 'Q']
#capacidade do barco
num_ocupantes_barco = 3
#Gerando os conjuntos de restricoes
global restr_sep
restr_sep = [x.split(',') for x in restricoes]
def valida_margem(margem):
#Se o fazendeiro está na margem, nao tem problema
if not ('F' in margem):
combinacoes = list(itertools.combinations(margem, 2))
for i in combinacoes: #passando por todas as combinacoes, 2 a 2, dos elementos da margem
for j in restr_sep: #passando pelas restricoes
if (
set(i) == set(j)
): #comparando se as combinacoes batem com alguma das restricoes -> movimento invalido
return False
return True
#verifica se um no ja existe
def ja_existe(msg, id_pai_atual):
#separa a msg no |(que se refere ao rio). Assim, ficamos com os vetores referentes as margens esquerda e direita
msg_arr = msg.split('|')
msg_arr_esq = msg_arr[0].split(
) #elementos presentes na margem esquerda
msg_arr_dir = msg_arr[1].split(
) #elementos presentes na margem direita
#iterando sobre os nos presentes na arvore para verificar se existe um no que tenha como dado o mesmo valor presente em msg
for i in arvore.getAllNodes():
dado_no = i.getData().split(
'|'
) #divide a mensagem em margem direita e esquerda por meio do sinal |
dado_no_esq = dado_no[0].split(
) #elementos referentes a margem esquerda
dado_no_dir = dado_no[1].split(
) #elementos referentes a margem esquerda
if (
(sorted(dado_no_esq) == sorted(msg_arr_esq))
or (sorted(dado_no_dir) == sorted(msg_arr_dir))
): #trabalha com os elementos ordenados JA que, para o problema, A B seja igual a B A
if (i.getId() <= ((id_pai_atual) - 1)) or (
i.getId() == 0
): #testa se o id do no igual é o inicial ou se esta pelo menos 1 valor atras do atual
return True
return False #o no ainda nao existe, ou sua criacao nao resulta em um loop
def calcula_custo(estado_pai, estado_filho):
custo = 0
quem_viajou = []
margens_pai = estado_pai.split('|')
margem_dir_pai = margens_pai[0].split()
margem_esq_pai = margens_pai[1].split()
margens_filho = estado_filho.split('|')
margem_dir_filho = margens_filho[0].split()
margem_esq_filho = margens_filho[1].split()
if ('F' in margem_dir_pai):
quem_viajou = list(
set(margem_dir_pai) -
set(margem_dir_pai).intersection(set(margem_dir_filho)))
else:
quem_viajou = list(
set(margem_esq_pai) -
set(margem_esq_pai).intersection(set(margem_esq_filho)))
for ator in personagens:
custo = custo + (ator in quem_viajou) * pesos[ator]
return custo
arestas = []
custos_arestas = dict()
custo_transicao = 0
#enquanto o id do no atual nao ultrapassar o numero de nos da arvore(caso em que a geracao da arvore deve encerrar, pois o ultimo no foi atingido e nao gerou nenhum filho)
while (id_pai < len(arvore.getAllNodes())):
num_gerados = 0 #ainda nao gerou nenhum filho
#recupera o no atual
no = arvore.getNode(id_pai)
#recupera a informacao presente no nó, referente à modelagem das margens esquerda e direita
margens = no.getData().split('|')
margem_esq = margens[0].split()
margem_dir = margens[1].split()
#se o fazendeiro esta na margem esquerda, o barco saira dela
if ('F' in margem_esq):
for k in range(num_ocupantes_barco):
#gera as combinacoes, 1 a 1 e 2 a 2, dos elementos da margem esquerda para que ocupem o barco, nao excedendo sua capacidade
combinacoes = list(itertools.combinations(margem_esq, k + 1))
for barco in combinacoes:
#se o fazendeiro esta no barco, a configuracao do barco eh valida, ja que soh o fazendeiro pode guia-lo
if ('F' in barco):
#a margem esquerda apos a saida dos ocupantes do barco
margem_esq_resultante = list(
set(margem_esq) - set(barco))
#testa se a configuracao da margem, caso os ocupantes do barco zarpem, continua valida segundo as restricoes do problema
if (valida_margem(margem_esq_resultante)):
#constroi a mensagem referente ao estado do no, na forma: margem_esquerda|margem_direita
if (len(margem_esq_resultante)):
margem_esq_resultante = sorted(
margem_esq_resultante)
msg = margem_esq_resultante[0]
for i in range(1, len(margem_esq_resultante)):
msg = msg + ' ' + margem_esq_resultante[i]
else:
msg = ''
msg = msg + '|'
margem_dir_resultante = list(
set(margem_dir).union(set(barco))
) #a margem direita apos a chegada dos ocupantes do barco
if (len(margem_dir_resultante)):
margem_dir_resultante = sorted(
margem_dir_resultante)
msg = msg + margem_dir_resultante[0]
for i in range(1, len(margem_dir_resultante)):
msg = msg + ' ' + margem_dir_resultante[i]
else:
msg = msg + ''
if (not ja_existe(
msg, id_pai)): #se o no ainda nao existe
id = id + 1
aresta = (arvore.getNode(id_pai).getData(),
msg)
arestas.append(aresta)
custo_transicao = calcula_custo(
arvore.getNode(id_pai).getData(), msg)
custos_arestas[aresta] = custo_transicao
arvore.addNode(msg, id, custo_transicao,
id_pai) #cria um novo no
else:
# se o fazendeiro esta na margem esquerda, o barco saira dela
if ('F' in margem_dir):
for k in range(num_ocupantes_barco):
# gera as combinacoes, 1 a 1 e 2 a 2, dos elementos da margem esquerda para que ocupem o barco, nao excedendo sua capacidade
combinacoes = list(
itertools.combinations(margem_dir, k + 1))
for barco in combinacoes:
# se o fazendeiro esta no barco, a configuracao do barco eh valida, ja que soh o fazendeiro pode guia-lo
if ('F' in barco):
# a margem direita apos a saida dos ocupantes do barco
margem_dir_resultante = list(
set(margem_dir) - set(barco))
# testa se a configuracao da margem, caso os ocupantes do barco zarpem, continua valida segundo as restricoes do problema
if (valida_margem(margem_dir_resultante)):
# a margem esquerda apos a chegada dos ocupantes do barco
margem_esq_resultante = list(
set(margem_esq).union(set(barco)))
# constroi a mensagem referente ao estado do no, na forma: margem_esquerda|margem_direita
if (len(margem_esq_resultante)):
margem_esq_resultante = sorted(
margem_esq_resultante)
msg = margem_esq_resultante[0]
for i in range(1,
len(margem_esq_resultante)):
msg = msg + ' ' + margem_esq_resultante[
i]
else:
msg = ''
msg = msg + '|'
if (len(margem_dir_resultante)):
margem_dir_resultante = sorted(
margem_dir_resultante)
msg = msg + margem_dir_resultante[0]
for i in range(1,
len(margem_dir_resultante)):
msg = msg + ' ' + margem_dir_resultante[
i]
else:
msg = msg + ''
if (not ja_existe(
msg,
id_pai)): #se o no ainda nao existe
id = id + 1
aresta = (arvore.getNode(id_pai).getData(),
msg)
arestas.append(aresta)
custo_transicao = calcula_custo(
arvore.getNode(id_pai).getData(), msg)
custos_arestas[aresta] = custo_transicao
arvore.addNode(msg, id, custo_transicao,
id_pai) #cria um novo no
#vai para o proximo no
id_pai = id_pai + 1
def converteDicToList(dicionario):
num_nos = len(arvore.getAllNodes())
lista = np.zeros(num_nos)
for no in arvore.getAllNodes():
for chave in dicionario:
if chave == no.getData():
lista[no.getId()] = dicionario[chave]
break
return lista
for i in arvore.getAllNodes():
print(i.getData())
#exibe o grafo gerado
'''f = open("grafo.txt","w+")
print("\n\nPrintando grafo")
for i in arvore.getAllNodes():
f.write("-----\n")
print("-----")
f.write("[" + str(i.getId()) + "]\n")
print("[", i.getId(),"]")
if(not i.getParent() is None):
f.write("Meu papai eh: " + str(i.getParent()) + "\n")
print("Meu papai eh: " + str(i.getParent()))
else:
f.write("Nao tenho papai :(\n")
print("Nao tenho papai :(")
f.write("Minha informacao eh: " + str(i.getData()) + "\n")
print("Minha informacao eh: ", i.getData())
f.write("Meus filhinhos sao: " + str(i.getChildren()) + "\n")
print("Meus filhinhos sao: ", i.getChildren())
f.write("Os peso pra ir nos meus filhinhos são: " + str(i.getPesosParaOsFilhos()) + "\n\n")
print("Os peso pra ir nos meus filhinhos são: ", i.getPesosParaOsFilhos())
f.close()'''
caminho_busca_largura = arvore.buscaLargura(arvore)
vet_dist_estado_final = converteDicToList(dicionario_heuristica_5_itens)
caminho_busca_a_estrela = arvore.busca_A_estrela(arvore,
vet_dist_estado_final)
#Parte de exibição **********************************************
nos = [v.getData() for v in arvore.getAllNodes()]
g = nx.Graph()
g.add_nodes_from(nos)
g.add_edges_from(arestas)
permutacoes_personagens = list(
itertools.permutations(personagens, len(personagens)))
nos_finais = []
prim = True
for i in permutacoes_personagens:
msg = '|'
for aux in i:
if (prim):
msg = msg + aux
prim = False
else:
msg = msg + ' ' + aux
prim = True
nos_finais.append(msg)
caminho_sem_no_final_e_sem_no_inicial = list(
set(caminho_busca_largura) -
set(caminho_busca_largura).intersection(set(nos_finais)) -
set('A B F L|')) #caminho sem o no final
#pinta de verde o caminho encontrado pela busca em largura, de vermelho o no final e de azul os demais nos
node_colors = [
'purple' if n == 'C F G Q R|' else 'yellow' if n in nos_finais else
'green' if n in caminho_sem_no_final_e_sem_no_inicial else 'blue'
for n in g.nodes()
]
#legenda
'''green_patch = mpatches.Patch(color='green', label='Menor caminho')
blue_patch = mpatches.Patch(color='blue', label='Nos nao visitados')
plt.legend(handles=[green_patch,blue_patch])'''
pos = nx.spring_layout(g)
nx.draw(g,
pos=pos,
with_labels=True,
node_size=700,
node_color=node_colors)
nx.draw_networkx_edge_labels(g, pos=pos, edge_labels=custos_arestas)
plt.savefig('grafo2.png')
plt.show(block=False)
plt.close()
#exibir em janela
root = Tk()
root.geometry("1000x620+0+0")
root.title("IA - Travessia do rio")
#Frame superior ********************************
FImgs = Frame(root, width=700, height=500, bd=1, relief=SUNKEN)
FImgs.grid(row=0, padx=10, pady=15)
#imagem = cv2.imread("grafo1.png")
#imagem = cv2.resize(imagem, None, fx=1.3, fy=1.3)
#cv2.imwrite("grafo1.png", imagem)
imgEntrada = PhotoImage(file="grafo2.png")
labelImgEntrada = Label(FImgs, image=imgEntrada)
labelImgEntrada.pack(side=LEFT, padx=15, pady=15)
FLegenda = Frame(root, width=700, height=60, bd=1, relief=SUNKEN)
FLegenda.grid(row=1)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT)
greenCircle = canvas.create_oval(10, 10, 40, 40, fill="green")
Label(FLegenda, text="Caminho resultante").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
purpleCircle = canvas.create_oval(10, 10, 40, 40, fill="purple")
Label(FLegenda, text="Estado inicial").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
yellowCircle = canvas.create_oval(10, 10, 40, 40, fill="yellow")
Label(FLegenda, text="Estado final").pack(side=LEFT)
canvas = Canvas(FLegenda, width=50, height=50)
canvas.pack(side=LEFT, padx=10)
blueCircle = canvas.create_oval(10, 10, 40, 40, fill="blue")
Label(FLegenda, text="Estado do grafo").pack(side=LEFT)
FResultadoBuscaLargura = Frame(root,
width=300,
height=500,
bd=1,
relief=SUNKEN)
FResultadoBuscaLargura.grid(row=0, column=1)
Label(FResultadoBuscaLargura,
text='Resultado Busca em Largura',
justify=CENTER).grid(row=0, pady=10, sticky=W)
i = 1
for estado in caminho_busca_largura:
Label(FResultadoBuscaLargura, text=estado,
justify=CENTER).grid(row=i, pady=10)
i += 1
FResultadoBuscaAEstrela = Frame(root,
width=300,
height=500,
bd=1,
relief=SUNKEN)
FResultadoBuscaAEstrela.grid(row=0, column=2, padx=15)
Label(FResultadoBuscaAEstrela, text='Resultado Busca A*',
justify=CENTER).grid(row=0, pady=10, sticky=W)
i = 1
for no in caminho_busca_a_estrela:
Label(FResultadoBuscaAEstrela, text=no.getData(),
justify=CENTER).grid(row=i, pady=10)
i += 1
root.mainloop()
for index in indices:
newstate = deepcopy(state)
if (numFreeSpots % 2) == 0:
newstate[index] = 'X'
else:
newstate[index] = 'O'
newnode = tree.addNode(node, newstate)
if newnode.depth < maxdepth:
recurse(newnode)
recurse(tree.root)
constructTree(4)
n = tree.walk(0, tree.root)
print(n)
"""
tree = Tree()
tree.addNode(tree.root, 9)
tree.addNode(tree.root, 10)
tree.addNode(tree.root, 11)
tree.addNode(tree.root.children[0], 4)
tree.addNode(tree.root.children[0], 6)
tree.addNode(tree.root.children[1], 8)
tree.addNode(tree.root.children[1], 1)
tree.addNode(tree.root.children[2], 7)
tree.addNode(tree.root.children[2], 90)
tree.addNode(tree.root.children[2], 66)
tree.addNode(tree.root.children[0].children[1], 78)
tree.addNode(tree.root.children[0].children[1], 99)
#tree.walk(0, tree.root)
return True
#Testa se a configuracao da margem eh valida
#Para a margem esquerda e Para a margem direita
#if(testa_margem_valida(margens[0]) and testa_margem_valida(margens[1])):
#pode ir para o no
#comecamos com id(atual) = id)pai = ROOT
id = ROOT
id_pai = ROOT
#criando objeto arvore
arvore = Tree()
#inserindo o no raiz
arvore.addNode("L B A F|", 0)
'''arvore.addNode("L A|F B", 1)
arvore.addNode("L A F|B", 2)
arvore.addNode("L|F A B", 3)
arvore.addNode("L B F|A", 4)
arvore.addNode("B|F A L", 5)
arvore.addNode("F B|A L", 6)
arvore.addNode("|F B A L", 7)'''
#verifica se um no ja existe
def ja_existe(msg, id_pai_atual):
#separa a msg no |(que se refere ao rio). Assim, ficamos com os vetores referentes as margens esquerda e direita
msg_arr = msg.split('|')
msg_arr_esq = msg_arr[0].split() #elementos presentes na margem esquerda
from node import Node
from tree import Tree
from random import randrange
if __name__ == "__main__":
arr = [randrange(1,100) for i in range(100)]
#[print(i) for i in arr]
tree = Tree(verbose=False)
[tree.addNode(i) for i in arr]
print("tree height: ", tree.getHeight())
tree.display()
tree.getInOrder()
tree.getPreOrder()
tree.findValue(10)
class Parser:
def __init__(self, tokens, verbose, printmode, program):
# Reverses tokens so I can use pop...cleans
# up the code significantly
self.__tokens = tokens[::-1]
self.cst = Tree(printmode)
self.verbose = verbose
self.warnings = 0
self.errors = 0
self.program = program
self.parse()
# Check if the current token is an appropriate token for the scope
def match(self, current_token, expected_tokens):
retval = False
if current_token in expected_tokens:
retval = True
return retval
# This handles all error messages
# as it was getting messy inside of function
def error(self, token, expected):
if self.errors is 0:
Error('Parser', f'Expected [ {expected} ] found [ {token.value} ]',
token.line, token.position)
self.errors += 1
def exit(self):
# Fail the Parser if there were any errors
if self.errors > 0:
print(colored(f'Parse Failed for Program {self.program}.\n',
'red'))
else:
print(
colored(f'Parse Completed for Program {self.program}.\n',
'magenta',
attrs=['bold']))
def logProduction(self, fn):
if self.verbose and self.errors is 0:
print(colored(f'PARSER ❯ {fn}', 'magenta'))
''' All productions to preform "derivations" '''
def parse(self):
print(
colored(f'Parsing Program {self.program}',
'magenta',
attrs=['bold']))
self.logProduction('parse()')
self.cst.addNode('program', 'branch')
# This is grabbing the first token but not removing it,
# this is so if the first '{' is left out we can say what was
# in its place
current_token = self.__tokens[-1]
# The most basic program is <block>$,
# so check for block and then $
if self.parseBlock():
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_EOP'):
self.cst.cutOffChildren()
# print(current_token.line)
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# We finished with 0 errors, exit safely now.
self.exit()
else:
self.error(current_token, '$')
else:
self.error(current_token, '{')
def parseBlock(self):
# Look at the next token but dont remove until we are sure this is a print statement
current_token = self.__tokens[-1]
# Match open brace of block
if self.match(current_token.kind, 'T_LEFT_BRACE'):
# Actually remove it now
current_token = self.__tokens.pop()
# New Block
self.logProduction('parseBlock()')
self.cst.addNode('Block', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# Check the contents of the block
if self.parseStatementList():
# There better be a right brace to close this block
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_RIGHT_BRACE'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
else:
self.error(current_token, '}')
return False
# This is a valid block
return True
else:
# No block detected, move on
return False
def parseStatementList(self):
self.logProduction('parseStatementList()')
self.cst.addNode('StatementList', 'branch')
if self.parseStatement():
# Move up the tree
self.cst.cutOffChildren()
return self.parseStatementList()
else:
while self.cst.current_node.name is 'StatementList':
self.cst.cutOffChildren()
# Epsilon
return True
def parseStatement(self):
self.logProduction('parseStatement()')
self.cst.addNode('Statement', 'branch')
# Check all possible statements
if self.parseBlock() or self.parsePrintStatement() or (
self.parseAssignmentStatement() or self.parseIfStatement()
or self.parseVarDecl() or self.parseWhileStatement()):
self.cst.cutOffChildren()
return True
else:
# Remove the Statement branch node we didnt need it
self.cst.delCurNode()
return False
# All possible statements
def parsePrintStatement(self):
# Look at the next token but dont remove until we are sure this is a print statement
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_PRINT'):
# Actually remove it now
current_token = self.__tokens.pop()
# New Print Statement
self.logProduction('parsePrintStatement()')
self.cst.addNode('PrintStatement', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
current_token = self.__tokens.pop()
# The next token better be a open paren
if self.match(current_token.kind, 'T_LEFT_PAREN'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# Check for expr inside parens
if self.parseExpr():
self.cst.cutOffChildren()
# Check for closing paren
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_RIGHT_PAREN'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
return True
else:
self.error(current_token, ')')
else:
self.error(current_token, 'ID, Int, String, or Boolean')
else:
self.error(current_token, '(')
else:
return False
def parseAssignmentStatement(self):
# Look at the next token but dont remove until we are sure this is a print statement
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_DIGIT') or self.match(
current_token.kind, 'T_QUOTE'):
self.error(current_token, 'ID')
if self.match(current_token.kind, 'T_ID'):
# We are sure this is a Assignment so pop the token
self.logProduction('parseAssignmentStatement()')
self.cst.addNode('AssignmentStatement', 'branch')
self.parseId()
current_token = self.__tokens.pop()
# Now look for the actual '='
if self.match(current_token.kind, 'T_ASSIGN_OP'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# Finally validate what the ID is being assigned to
if self.parseExpr():
self.cst.cutOffChildren()
return True
else:
self.error(current_token, 'ID, Int, String, or Boolean')
else:
self.error(current_token, '=') # T_ASSIGN_OP
else:
# Not an Assignment statement or not
# valid(didnt start with a ID)
return False
def parseVarDecl(self):
# Look at the next token but dont remove until we are sure this is a print statement
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_TYPE'):
# We are sure this is a Assignment so pop the token
current_token = self.__tokens.pop()
self.logProduction('parseVarDecl()')
self.cst.addNode('VarDecleration', 'branch')
self.parseType(current_token)
current_token = self.__tokens[-1]
if self.parseId():
return True
else:
self.error(current_token, 'ID')
else:
# Not a valid decleration
return False
def parseWhileStatement(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_WHILE'):
current_token = self.__tokens.pop()
self.logProduction('parseWhileStatement()')
self.cst.addNode('WhileStatement', 'branch')
if self.parseBooleanExpr():
self.cst.cutOffChildren()
if self.parseBlock():
self.cst.cutOffChildren()
return True
else:
self.error(self.__tokens[-1], '{')
return False
else:
self.error(self.__tokens[-1], 'BooleanExpr')
return False
else:
return False
def parseIfStatement(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_IF'):
current_token = self.__tokens.pop()
self.logProduction('parseIfStatement()')
self.cst.addNode('IfStatement', 'branch')
if self.parseBooleanExpr():
self.cst.cutOffChildren()
if self.parseBlock():
self.cst.cutOffChildren()
return True
else:
self.error(self.__tokens[-1], 'T_LEFT_BRACE')
return False
else:
self.error(self.__tokens[-1], 'BooleanExpr')
return False
else:
return False
# Expressions
def parseExpr(self):
self.logProduction('parseExpr()')
self.cst.addNode('Expr', 'branch')
# New Expr INT, BOOL or String
if self.parseIntExpr() or self.parseBooleanExpr(
) or self.parseStringExpr():
self.cst.cutOffChildren()
return True
elif self.parseId():
# New Expr ID
return True
else:
return False
def parseIntExpr(self):
# Look at the next token but dont remove until we are sure this is a print statement
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_DIGIT'):
self.logProduction('parseIntExpr()')
self.cst.addNode('IntExpr', 'branch')
if self.parseDigit():
if self.parseIntOp():
if self.parseExpr():
self.cst.cutOffChildren()
return True
else:
self.error(current_token, 'Expr')
else:
# this is valid => a = 3
return True
else:
self.error(current_token, 'digit(0-9)')
else:
# Its not a IntEpr
return False
def parseStringExpr(self):
# Check for quote else dis aint a string
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_QUOTE'):
current_token = self.__tokens.pop()
self.logProduction('parseStringExpr()')
self.cst.addNode('StringExpr', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
self.cst.addNode('CharList', 'branch')
if self.parseCharList():
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_QUOTE'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
return True
else:
self.error(self.__tokens[-1], 'T_Quote')
else:
self.error(self.__tokens[-1], 'Charlist')
else:
return False
def parseBooleanExpr(self):
# Check for BoolOp first
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_BOOLEAN'):
self.logProduction('parseBooleanExpr()')
self.cst.addNode('BooleanExpr', 'branch')
self.parseBoolVal()
return True
elif self.match(current_token.kind, 'T_LEFT_PAREN'):
current_token = self.__tokens.pop()
self.logProduction('parseBooleanExpr()')
self.cst.addNode('BooleanExpr', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
if self.parseExpr():
self.cst.cutOffChildren()
if self.parseBoolOp():
if self.parseExpr():
self.cst.cutOffChildren()
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_RIGHT_PAREN'):
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
return True
else:
self.error(current_token, ')')
else:
self.error(current_token, 'Expr')
else:
self.error(current_token, '== or !=')
else:
self.error(current_token, 'Expr')
else:
# Not a valid BoolExpr
return False
def parseId(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_ID'):
current_token = self.__tokens.pop()
# We dont need to check for char as
# the lexer already took care of that
self.logProduction('parseId()')
self.cst.addNode('Id', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# go back to parent node
self.cst.cutOffChildren()
return True
else:
return False
def parseCharList(self):
self.logProduction('parseCharList()')
if self.parseChar():
return self.parseCharList()
else:
# move back up tree to get back to the branch node
while self.cst.current_node.name is 'CharList':
self.cst.cutOffChildren()
return True
def parseType(self, type_token):
self.logProduction('parseType()')
self.cst.addNode('Type', 'branch')
self.cst.addNode(type_token.value,
'leaf',
line=type_token.line,
pos=type_token.position)
# go back to parent node
self.cst.cutOffChildren()
def parseChar(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_CHAR'):
current_token = self.__tokens.pop()
self.logProduction('parseChar()')
self.cst.addNode('char', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# go back to parent node
self.cst.cutOffChildren()
return True
else:
# Not a char
return False
def parseDigit(self):
self.logProduction('parseDigit()')
current_token = self.__tokens.pop()
if self.match(current_token.kind, 'T_DIGIT'):
self.cst.addNode('digit', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
# go back to parent node
self.cst.cutOffChildren()
return True
else:
return False
def parseBoolOp(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_BOOL_OP'):
current_token = self.__tokens.pop()
self.logProduction('parseBoolOp()')
self.cst.addNode('BoolOp', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
self.cst.cutOffChildren()
return True
else:
return False
def parseBoolVal(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_BOOLEAN'):
current_token = self.__tokens.pop()
self.logProduction('parseBoolVal()')
self.cst.addNode('BoolVal', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
self.cst.cutOffChildren()
return True
else:
return False
def parseIntOp(self):
current_token = self.__tokens[-1]
if self.match(current_token.kind, 'T_ADDITION_OP'):
current_token = self.__tokens.pop()
self.cst.addNode('IntOP', 'branch')
self.cst.addNode(current_token.value,
'leaf',
line=current_token.line,
pos=current_token.position)
self.cst.cutOffChildren()
return True
else:
return False
