def _query(pl=None, query=None, debug=False):
if not query:
return
if not pl:
pl = Prolog()
pl.consult('init.pl')
if isinstance(query[0], str):
query = [query]
query_list = []
var_list = []
for pred, args in query:
arg_list = []
for arg in args:
if (isinstance(arg, str) and arg[:3] == '_v:'):
# and arg[0] == arg[0].upper()
var = arg[3:]
var_list += [var]
arg_list += [var]
elif (isinstance(arg, str) and '^^' in arg):
arg_list += [arg]
elif (isinstance(arg, list)):
arg_list += [f"{arg}"]
else:
arg_list += [f"'{arg}'"]
arg_str = ','.join(arg_list)
query_list += [pred + '(' + arg_str + ')']
query_str = ','.join(query_list)
if debug:
print(query_str, end="\n\n")
return var_list, pl.query(query_str)
def findShortestPath(from_input, to_input):
prolog = Prolog()
loadDatabase(prolog)
prolog_query = "path(" + from_input + "," + to_input + ",PATH,COST)"
shortest_path_result = list(prolog.query(prolog_query))
path_list = []
shortest_path_lst = shortest_path_result
if len(shortest_path_lst) <= 0:
return False
for i in range(len(shortest_path_lst[0]['PATH'])):
path_list.append(str(shortest_path_result[0]['PATH'][i]))
train_query = "theTrainIs(" + str(path_list) + ",TRAIN)"
train_result = list(prolog.query(train_query))
train_list = []
for i in range(len(train_result[0]['TRAIN'])):
train_list.append(str(train_result[0]['TRAIN'][i]))
path_type_list = []
include_walk_query = "includeWalk(" + str(train_list) + ",PATH_TYPE)"
include_walk_result = list(prolog.query(include_walk_query))
for i in range(len(include_walk_result[0]['PATH_TYPE'])):
path_type_list.append(str(include_walk_result[0]['PATH_TYPE'][i]))
print("Train: " + str(train_list))
print ""
print("Train+Walk: " + str(path_type_list))
print ""
print("TrainLen: " + str(len(train_list)) + "->" +
str(len(path_type_list)))
return path_list, shortest_path_result[0]['COST']
def main():
registerForeign(hello)
prolog = Prolog()
#prolog.assertz("father(michael,john)")
#prolog.assertz("father(michael,gina)")
#list(prolog.query("father(michael,X), hello(X)"))
Query(readFileSee('/home/tyler/Documents/Github/crosswordSolver/word_list.txt')))
def main():
prolog = Prolog()
#membuka file coins.pl
prolog.consult("prolog_file/coins.pl")
#mendeklarasi nilai count dan total
#menginputkan nilai count dan nilai total berupa angka
count = int(input("Berapa jumlah koin(default: 100)? ") or 100)
total = int(input("Jumlah target total (default: 500)? ") or 500)
#melakukan perulangan dengan menampilkan nilai yang ada di dalam list
#enumerate berfungsi untuk mengembalikan sebuah objek iterable yang setiap itemnya memiliki indeks
#memanggil fungsi coins pada prolog
for i, soln in enumerate(prolog.query("coins(S, %d, %d)." %
(count, total))):
# [1,5,10,50,100]
S = zip(soln["S"], [1, 5, 10, 50, 100])
print(i), #cetak nilai
#melakukan perulangan untuk menampilkan angka perkalian
for c, v in S:
print("%dx%d" % (c, v)), #cetak perkalian
print #cetak hasil perulangan
#fungsi list yaitu mengembalikan list berisi anggota-anggota dari objek yang menjadi argumennya
#jika argumennya kosong, maka fungsi ini akan mengembalikan list kosong
#jika argumennya berisikan data, maka yang digunakan adalah data-data yang digunakan dari list tersebut
#hasil akhirnya akan menampilkan perhitungan perkalian dari jumlah nilai yang diinputkan
list(prolog.query("coins(S, %d, %d)." % (count, total)))
def query_prolog(data, output):
from pyswip.prolog import Prolog
from pyswip.easy import call, Functor, registerForeign
prolog = Prolog() # handle for Prolog interpreter
# Fetch Prolog inputs
distance = str(data[0])
price = str(data[1])
type = str(data[2])
veg_options = str(data[3])
# open KB file from static location
prolog.consult('static/KB.pl')
# assert knowledge at top of KB
prolog.asserta("veg_options(" + veg_options + ")")
prolog.asserta("distance(" + distance + ")")
prolog.asserta("price(" + price + ")")
prolog.asserta("type(" + type + ")")
# get results from KB
results = [
sol['X'] for sol in prolog.query("recommendation(X).", maxresult=1)
]
if results:
output.put(("You should eat at " + results[0] + "!"))
else:
output.put(("No restaurant could be identified!"))
def main():
def notify(t):
print "move disk from %s pole to %s pole." % tuple(t)
notify.arity = 1
prolog = Prolog()
registerForeign(notify)
prolog.consult("hanoi.pl")
list(prolog.query("hanoi(%d)" % N))
def __init__( self, director, dificuldade ):
super( GameLayer, self ).__init__()
self.director = director
self.tabuleiro = []
self.offsetX = director.get_window_size()[0]/3
self.offsetY = director.get_window_size()[1]/8
lado = 45
self.lado = lado
self.dificuldade = dificuldade
self.cpu = False
self.prolog = Prolog()
self.prolog.consult("reversi.pl")
self.tabMatriz = list(self.prolog.query("novotab(X)"))[0]['X']
self.matriz = deepcopy(self.tabMatriz)
pyglet.font.add_directory('.')
self.jogadorAtivo = Label("Jogador: Player1", font_name = 'Blood Of Dracula', font_size = 22,
x = 20, y = 350)
self.add(self.jogadorAtivo)
self.dif = Label("Dificuldade: " + self.dificuldade, font_name = 'Blood Of Dracula', font_size = 16,
x = 20, y = 300)
self.add(self.dif)
self.p = list(self.prolog.query("winner(" + str(self.tabMatriz) + ", P0, P1, P2)"))[0]
self.p1 = Label("P1: " + str(self.p['P1']) + self.dificuldade, font_name = 'Bloodsuckers', font_size = 26,
x = 20, y = 200)
self.p2 = Label("P1: " + str(self.p['P2']) + self.dificuldade, font_name = 'Bloodsuckers', font_size = 26,
x = 20, y = 150)
self.add(self.p1)
self.add(self.p2)
#Batch que vai segurar todos os pecas
self.spriteBatch = BatchNode()
self.add(self.spriteBatch)
size = 8*self.lado
for i in range(8):
l = []
for j in range(8):
peca = Peca(self.tabMatriz[i][j], (j*lado + lado/2, size - (i*lado + lado/2)))
l.append(peca)
self.spriteBatch.add(peca)
self.tabuleiro.append(l)
self.spriteBatch.add(Sprite("tabuleiro.png",
(self.tabuleiro[4][4].position[0] - lado/2, self.tabuleiro[4][4].position[1] + lado/2)
, 0, 1, 32), 0)
self.spriteBatch.position = (self.offsetX, self.offsetY)
self.spriteBatch.scale = 1.0
self.hud = GameHud()
self.add(self.hud)
self.schedule(self.gameLoop)
def prologInitialization(self):
print "@Agent: Prolog initialization",
self.prolog = Prolog()
self.prolog.consult("pl/agent.pl")
if (self.logToFile):
self.prolog.query("redirect_output('logs/%s-kb%d.xml')" %
(self.username, self.currentLoop)).next()
if (self.verbose):
self.prolog.query("assert(verbose)").next()
print "done"
def main(): #digunakan untuk membuat fungsi main()
N = 3 #pendeklarasian nilai N adalah 3
INTERACTIVITY = True
prolog = Prolog()
tower = Tower(N, INTERACTIVITY)
notifier = Notifier(tower.move)
registerForeign(notifier.notify)
prolog.consult("prolog_file/hanoi.pl")
list(prolog.query("hanoi(%d)" % N))
def main():
N = 3
INTERACTIVITY = True
prolog = Prolog()
tower = Tower(N, INTERACTIVITY)
notifier = Notifier(tower.move)
registerForeign(notifier.notify)
prolog.consult("hanoi.pl")
list(prolog.query("hanoi(%d)" % N))
def imprimirRest():
p = Prolog()
p.consult('rest.pl')
resultados = []
for result in p.query("restaurante(A,_,_,_,_)"):
r = result["A"]
resultados.append(str(r))
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def __init__(self):
# http://nullege.com/codes/search/pyswip.prolog.Prolog.query
self.__root = ''
self.__on_prolog = 'prolog'
self.__of_prolog = 'halt.'
# Preguntas
self.__a_animal = 'animal(X).'
self.__prolog = Prolog()
self._probando()
def imprimirPlato():
p = Prolog()
p.consult("plati.pl")
resultados = []
for plato in p.query("platillo(_,A,_,_,_)"):
r = plato["A"]
resultados.append(str(r))
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def restaurantesXtipo(tipocomida):
p = Prolog()
p.consult("rest.pl")
resultados = []
for restaurante in p.query("restaurantesXtipo(A," + tipocomida + ")"):
r = restaurante["A"]
resultados.append(str(r))
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def buscaRestaurantesXPais(pais):
p = Prolog()
p.consult("plati.pl")
resultados = []
for restaurante in p.query("buscaRestXPais(Nombre," + pais + ")"):
r = restaurante["Nombre"]
resultados.append(str(r))
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def test_load_database(self):
try:
prolog = Prolog()
loadDatabase(prolog)
except:
print("ERROR: cannot load database")
finally:
# do something after show msg
pass
def run_prolog(pipe):
prolog = Prolog()
while True:
request = pipe.recv()
if request == 0:
break
request, args = request
func = getattr(prolog, request)
result = func(*args)
if result is not None:
result = list(result)
pipe.send(result)
def main():
prolog = Prolog()
prolog.consult("puzzle1.pl")
for soln in prolog.query("solve(B)."):
#B = eval(soln["B"])
B = soln["B"]
# [NW,N,NE,W,E,SW,S,SE]
print "%d %d %d" % tuple(B[:3])
print "%d %d" % tuple(B[3:5])
print "%d %d %d" % tuple(B[5:])
cont = raw_input("Press 'n' to finish: ")
if cont.lower() == "n": break
def main():
prolog = Prolog()
prolog.consult("puzzle.pl") #membaca file prolog (puzzle.pl)
for soln in prolog.query("solusi(B)."):
#B = eval(soln["B"])
B = soln["B"]
# [NW,N,NE,W,E,SW,S,SE]
print("%d %d %d" % tuple(B[:3]))
print("%d %d" % tuple(B[3:5]))
print("%d %d %d" % tuple(B[5:]))
cont = input("Tekan 'n' untuk selesai: ")
if cont.lower() == "n": break
def main():
prolog = Prolog()
prolog.consult("coins.pl")
count = int(input("How many coins (default: 100)? ") or 100)
total = int(input("What should be the total (default: 500)? ") or 500)
for i, soln in enumerate(prolog.query("coins(S, %d, %d)." % (count,total))):
# [1,5,10,50,100]
S = list(zip(soln["S"], [1, 5, 10, 50, 100]))
print(i, end=' ')
for c, v in S:
print("%dx%d" % (c,v), end=' ')
print()
list(prolog.query("coins(S, %d, %d)." % (count,total)))
def platillosXrestIngrediente(restaurante, ingrediente):
p = Prolog()
p.consult("plati.pl")
resultados = []
resultados.append("Lista de platillos de " + restaurante +
" que incluyen " + ingrediente + ":")
for restaurante in p.query("platillosXrestIngrediente(" + restaurante +
",Nombre,Sabor,Pais," + ingrediente + ")"):
resultados.append(restaurante["Nombre"])
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def main():
prolog = Prolog()
prolog.consult("prolog_file/puzzle1.pl") #membuka file prolog puzzle.pl
for soln in prolog.query(
"solve(B)."): #menjalankan predikat solve seperti pada file prolog
B = soln["B"]
# [NW,N,NE,W,E,SW,S,SE]
print("%d %d %d" % tuple(B[:3])) #mencetak angka pada papan
print("%d %d" % tuple(B[3:5]))
print("%d %d %d" % tuple(B[5:]))
cont = input("Press 'n' to finish: ")
if cont.lower() == "n": break #jika ditekan n, program selesai
def main():
prolog = Prolog()
prolog.consult("kanankiri.pl") #membaca file prolog (kanankiri.pl)
kiri = int(input("Berapa jumlahnya kiri? ") or 10)
total = int(input("Berapa total semuanya? ") or 100)
for i, soln in enumerate(
prolog.query("kanankiri(S, %d, %d)." % (kiri, total))):
S = zip(soln["S"], [1, 5, 10, 50, 100])
print(i),
for c, v in S:
print("%dx%d" % (c, v))
print()
list(prolog.query("kanankiri(S, %d, %d)." % (kiri, total)))
def findShortestPath(from_input, to_input):
prolog = Prolog()
loadDatabase(prolog)
prolog_query = "path(" + from_input + "," + to_input + ",PATH,COST)"
shortest_path_result = list(prolog.query(prolog_query))
path_list = []
shortest_path_lst = shortest_path_result
if len(shortest_path_lst) <= 0:
return False
for i in range(len(shortest_path_lst[0]['PATH'])):
path_list.append(str(shortest_path_result[0]['PATH'][i]))
return path_list, shortest_path_result[0]['COST']
def modified_run(self):
try:
from pyswip.prolog import Prolog
p = Prolog()
p.assertz('setup_prolog(1)')
list(p.query('setup_prolog(1)'))
except:
print('----------------------')
print('There is a problem with SWI-Prolog Installation')
print(
'Please, check if you have it installed with shared Libraries')
print(
'Installation guide: https://github.com/yuce/pyswip/blob/master/INSTALL'
)
print('----------------------')
orig_run(self)
def main():
prolog = Prolog()
a1 = PL_new_term_refs(2)
a2 = a1 + 1
t = PL_new_term_ref()
ta = PL_new_term_ref()
animal2 = PL_new_functor(PL_new_atom("animal"), 2)
assertz = PL_new_functor(PL_new_atom("assertz"), 1)
PL_put_atom_chars(a1, "gnu")
PL_put_integer(a2, 50)
PL_cons_functor_v(t, animal2, a1)
PL_cons_functor_v(ta, assertz, t)
PL_call(ta, None)
print(list(prolog.query("animal(X,Y)", catcherrors=True)))
def partial_diagnosis(self, symptoms):
prolog = Prolog()
for file in self.prolog_files:
prolog.consult(file)
differntial_diagnosis = []
for symptom in symptoms:
for result in prolog.query('hasSymptom(Illness, %s)' % symptom):
differntial_diagnosis.append(result['Illness'])
sick_list = []
# Removes multiple illnesses from the list
sick_list = list(set(differntial_diagnosis))
return sick_list
def main():
"""
Trying to modify this example https://github.com/yuce/pyswip/blob/master/examples/coins/coins.py
to provide a nice pythonic interface to petyhaker's code
"""
prolog = Prolog()
prolog.consult("agent.pl")
count = int(raw_input("How many coins (default: 100)? ") or 100)
total = int(raw_input("What should be the total (default: 500)? ") or 500)
for i, soln in enumerate(prolog.query("coins(S, %d, %d)." %
(count, total))):
# [1,5,10,50,100]
S = zip(soln["S"], [1, 5, 10, 50, 100])
print i,
for c, v in S:
print "%dx%d" % (c, v),
print
list(prolog.query("coins(S, %d, %d)." % (count, total)))
def buscaRestaurantesXNombre(nombre):
p = Prolog()
p.consult("rest.pl")
resultados = []
for restaurante in p.query("buscaRest(" + nombre + ",A,B,C,D)"):
temporal = []
tipo = restaurante["A"]
ubicacion = restaurante["B"]
telefono = str(restaurante["C"])
jornada = restaurante["D"]
temporal.append(str(tipo))
temporal.append(str(ubicacion))
temporal.append(str(telefono))
temporal.append(str(jornada))
temporal.append("Fin de restaurante")
resultados.append(temporal)
temporal = []
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
def buscaPlatillosRest(restaurante):
p = Prolog()
p.consult("plati.pl")
resultados = []
for restaurante in p.query("platillosXrest(" + restaurante +
",Nombre,Sabor,Pais,Ingredientes)"):
temporal = []
temporal.append("Nombre: " + str(restaurante["Nombre"]))
temporal.append("Sabor: " + str(restaurante["Sabor"]))
temporal.append("Pais de origen: " + restaurante["Pais"])
t = ""
for i in list(restaurante["Ingredientes"]):
t += str(i) + " - "
temporal.append(str("Ingredientes: " + t))
t = ""
resultados.append(temporal)
temporal = []
log = file("log.txt", "a")
log.write(str(resultados) + "\n")
log.close()
return resultados
