def _toAFD(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado> [minimo]" % (
args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Ejecutamos el metodo que transforma el AFND a AFD
af = af.toAFD()
# Revisamos si el parametro "minimo" fue ingresado
minimize = False
if (len(args) > 4 and args[4] == "minimo"):
minimize = True
# En caso de ser pedido minimizamos el AFD
if minimize:
af.minimize()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Paso a AFD terminado correctamente."
def _validar(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 3):
print "El uso del programa debe ser: %s %s <archivo de datos> [secuencia] (Si no se pasa secuencia se analizara la palabra vacia)" % (
args[0], args[1])
sys.exit()
# Cargamos el nombre del archivo con el AF
dataFile = args[2]
# Verificamos si el parametro "secuence" fue pasado, en caso contrario
# validaremos un string vacio
secuence = ""
if len(args) > 3:
secuence = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde el archivo
self._loadFromFile(af, dataFile)
# Ejecutamos la validacion
isValid = af.validateSecuence(secuence)
# Imprimimos el resultado
if isValid:
print "La secuencia '%s' es valida segun el AF determinado" % (
secuence)
else:
print "La secuencia '%s' NO es valida segun el AF determinado" % (
secuence)
def _complemento(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Ejecutamos el metodo que transforma el AFND a AFD
af = af.toAFD()
# Complementamos el AFD
af.complement()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Paso a AFD complementado correctamente, el AFD de resultado esta en: %s" % (resultFile)
def _validar(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 3):
print "El uso del programa debe ser: %s %s <archivo de datos> [secuencia] (Si no se pasa secuencia se analizara la palabra vacia)" % (args[0], args[1])
sys.exit()
# Cargamos el nombre del archivo con el AF
dataFile = args[2]
# Verificamos si el parametro "secuence" fue pasado, en caso contrario
# validaremos un string vacio
secuence = ""
if len(args) > 3:
secuence = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde el archivo
self._loadFromFile(af, dataFile)
# Ejecutamos la validacion
isValid = af.validateSecuence(secuence)
# Imprimimos el resultado
if isValid:
print "La secuencia '%s' es valida segun el AF determinado en %s" % (secuence, dataFile)
else:
print "La secuencia '%s' NO es valida segun el AF determinado en %s" % (secuence, dataFile)
def _toAFD(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado> [minimo]" % (args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Ejecutamos el metodo que transforma el AFND a AFD
af = af.toAFD()
# Revisamos si el parametro "minimo" fue ingresado
minimize = False
if(len(args) > 4 and args[4] == "minimo"):
minimize = True
# En caso de ser pedido minimizamos el AFD
if minimize:
af.minimize()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Paso a AFD %sterminado correctamente, el AFD de resultado esta en: %s" % ("minimo " if minimize else "", resultFile)
def _concatenacion(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 5):
print "El uso del programa debe ser: %s %s <archivo de datos 1> <archivo de datos 2> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
dataFileConcatenacion = args[3]
resultFile = args[4]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Instanciamos el segundo AF
afConcatenacion = AF()
# Cargamos el AF desde el segundo archivo
self._loadFromFile(afConcatenacion, dataFileConcatenacion)
# Unimos los AFDs
af.concat(afConcatenacion)
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Proceso de concatenacion de AFs terminado correctamente. Resultado guardado en: %s" % (resultFile)
def primer_AF():
return AF(estados={'q0', 'q1', 'q2', 'q3', 'q4'},
alfabeto={'a', 'b', 'c'},
transiciones={
'q0': {
'a': {'q2'},
'b': {'q1', 'q2'}
},
'q1': {
'a': {'q1'},
'b': {'q1'},
'c': {'q1', 'q2'}
},
'q2': {
'a': {'q3'},
'b': {'q2', 'q3'},
},
'q3': {
'a': {'q4'},
'b': {'q2'},
},
'q4': {
'c': {'q2'}
}
},
estado_inicial='q0',
estados_finales={'q4'})
def _minimizar(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde el archivo
self._loadFromFile(af, dataFile)
# Ejecutamos la minimizacion
af.minimize()
# Escribimos el AD minimizado en un archivo
self._writeOnFile(af, resultFile)
print "Minimizacion terminada correctamente, el AFD de resultado esta en: %s" % (resultFile)
def _noAceptarVacia(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Ejecutamos el proceso en el AFD
af.noAceptarVacia()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Proceso de NO aceptacion de la palabra vacia en el AF terminado correctamente. Resultado guardado en: %s" % (resultFile)
def _kleene(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Ejecutamos el proceso en el AFD
af.kleene()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "AF transformado a AF* correctamente. Resultado guardado en: %s" % (resultFile)
def completions(self, caf, arguments_to_add=None, relations_to_add=None):
""" Return all possible completions of a given caf.
Also has the possibility to add extra arguments or attack
relations to all completions this function returns. This can be
useful when calculating the completions of a caf under a certain
control configuration.
"""
if arguments_to_add is None:
arguments_to_add = set()
if relations_to_add is None:
relations_to_add = set()
all_comp = set()
# For every combination of uncertain arguments,
for u_comb in self.powerset(caf.arg_u):
u_comb = set(u_comb)
this_args = caf.arg_f | u_comb | set(arguments_to_add)
# Find all combination of uncertain attacks for this
# combination of arguments
u_attack_combs = self.powerset([
u_attack for u_attack in caf.att_u
if u_attack.arg_start in this_args
and u_attack.arg_end in this_args
])
for u_attack_comb in u_attack_combs:
u_attack_comb = set(u_attack_comb)
this_attacks = caf.att_f | u_attack_comb | relations_to_add
bidir_combs = self.powerset([
bidir for bidir in caf.att_b if
bidir.arg_start in this_args and bidir.arg_end in this_args
])
# Find all combination of bidirectional attacks for this
# combination of arguments and uncertain attacks
for bidir_comb in bidir_combs:
# For every bidirectional, add one of the two
# directions. Note inversion of start and end!
all_comp.add(
AF(args=this_args,
attacks=this_attacks | {
bidir if bidir in bidir_comb else Attack(
arg_start=bidir.arg_end,
arg_end=bidir.arg_start)
for bidir in caf.att_b
}))
return all_comp
def _potencia(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 4):
print "El uso del programa debe ser: %s %s <archivo de datos> <archivo de resultado> <potencia>" % (args[0], args[1])
sys.exit()
n = 1
try:
n = int(args[4])
except:
print "El uso del programa debe ser: %s %s %s <archivo de resultado> <potencia>" % (args[0], args[1], args[2])
sys.exit()
# Cargamos el nombre del archivo con el AF
dataFile = args[2]
resultFile = args[3]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde el archivo
self._loadFromFile(af, dataFile)
# Concatenamos una copia del AF a si mismo n-1 veces
n -= 1
for i in xrange(n):
copyAF = copy.deepcopy(af)
af.concat(copyAF)
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
# Imprimimos el resultado
print "AF elevado a la %s potencia. Resultado guardado en %s" % (str(n + 1), resultFile)
def segundo_AF():
return AF(estados={'S', 'A', 'B', 'C', 'D', 'E', 'F'},
alfabeto={'a', 'b', 'c'},
transiciones={
'S': {
'a': {'A', 'D', 'F'},
'b': {'C', 'D', 'F'},
},
'A': {},
'B': {
'b': {'A', 'B', 'F'},
},
'C': {},
'D': {
'a': {'C'},
'c': {'E'}
},
'E': {
'b': {'F'},
},
'F': {}
},
estado_inicial='S',
estados_finales={'F'})
from af import AF, estado
af = AF(['a', 'b', 'c', 'd'])
q0 = estado('q0', 'i')
q1 = estado('q1', '')
q2 = estado('q2', '')
q3 = estado('q3', '')
q4 = estado('q4', 'f')
q5 = estado('q5', 'f')
q6 = estado('q6', 'f')
af.transicao(q0, q0, ['a'])
af.transicao(q0, q1, ['a'])
af.transicao(q1, q2, ['b'])
af.transicao(q1, q3, ['b'])
af.transicao(q1, q5, ['b'])
af.transicao(q2, q1, ['a'])
af.transicao(q3, q4, ['c'])
af.transicao(q4, q4, ['c'])
af.transicao(q5, q6, ['c'])
af.transicao(q6, q6, ['d'])
af.testa('abe')
print()
af.testa('abc')
print()
af.testa('abcd')
print()
af.testa('abbbbcd')
def _interseccion(self, args):
# Verificamos que tenemos todos los parametros necesarios
if (len(args) < 5):
print "El uso del programa debe ser: %s %s <archivo de datos 1> <archivo de datos 2> <archivo de resultado>" % (args[0], args[1])
sys.exit()
dataFile = args[2]
dataFileInterseccion = args[3]
resultFile = args[4]
# Instanciamos un AF
af = AF()
# Cargamos el AF desde un archivo
self._loadFromFile(af, dataFile)
# Instanciamos el segundo AF
afInterseccion = AF()
# Cargamos el AF desde el segundo archivo
self._loadFromFile(afInterseccion, dataFileInterseccion)
# La interseccion de M1 y M2 se define como:
# (M1c U M2c)c
# 1.- Complementamos cada AF
af.complement()
afInterseccion.complement()
# 2.- Unimos el segundo AF al primero
af.union(afInterseccion)
# 3.- Complementamos el af de la union
af.complement()
# Escribimos el AFD en un archivo
self._writeOnFile(af, resultFile)
print "Proceso de interseccion de AFs terminado correctamente. Resultado guardado en: %s" % (resultFile)
def automata(estados, alfabeto, transiciones, estado_inicial, estados_finales):
return AF(estados=estados,
alfabeto=alfabeto,
transiciones=transiciones,
estado_inicial=estado_inicial,
estados_finales=estados_finales)
def generate_afs(num_arguments,
offers,
agent_names,
args,
attacks,
all_args=cf.ALL_ARGS_IN_AF,
arguments_af=None,
p_attack_AF=cf.P_ATTACK_IN_AF):
""" Generate the agents' AFs. """
afs = dict()
for agent_name in agent_names:
# If the "All args" parameter is enabled, the AF contains all
# arguments in the pool.
if all_args:
this_args = args
# If the number of arguments is specified exactly, then sample
# this many arguments
elif arguments_af:
this_args = set(random.sample(population=args, k=arguments_af))
# If no exact number was specified, then sample between a range
else:
this_args = set(
random.sample(population=args,
k=random.randint(
max(cf.MIN_ARGUMENTS_AF, cf.NUM_OFFERS),
min(cf.MAX_ARGUMENTS_AF, num_arguments))))
# If not enough practical arguments to hold the number of
# offers, then remove and add arguments until enough
while len(offers) > len(
[prc for prc in this_args if prc.PEtype == 'practical']):
this_args.pop()
new_arg = random.choice([
prc for prc in args
if prc.PEtype == 'practical' and prc not in this_args
])
this_args.add(new_arg)
this_attacks = set()
for attack in attacks:
if (attack.arg_start in this_args and attack.arg_end in this_args):
rand = random.random()
# Add valid attacks with a probability
if rand < p_attack_AF:
this_attacks.add(attack)
supp_args = dict()
# List the practical arguments
pracs = [prc for prc in this_args if prc.PEtype == 'practical']
# Give a practical argument to every offer
for offer in offers:
prc = random.choice(pracs)
supp_args[offer] = {prc}
pracs.remove(prc)
# Share the remaining practical arguments over the offers
for prc in pracs:
offer = random.choice(offers)
supp_args[offer].add(prc)
pracs.remove(prc)
afs[agent_name] = AF(args=this_args,
attacks=this_attacks,
supp_args=supp_args)
return afs
