INTELIGENCIA ARTIFICIAL 1 INFORME FINAL DE ... - Wiphala.net

INFORME FINAL DE INTELIGENCIA ARTIFICIAL
TEMA : Agente Reflejo Simple y Agente de Búsqueda
ALUMNOS : SECCION
Condezo Fernández, Gerardo 2006147157 46J
Domínguez Rojas, Bilha 1995109117 45J
Manco Fernández, Renzo 2003194158 46J
Nuñez Velarde, Cynthia 2001124643 45J
Reyes Ubilluz, Jose 2003201199 45J
Saldarriaga Coveñas, Diana 2001225361 46J
CURSO : Inteligencia Artificial.
PROFESOR : Samuel Oporto Díaz.
La Molina, 18 de Junio del 2009
INTELIGENCIA ARTIFICIAL 1

INDICE
RESUMEN ...................................................................................................................
INTRODUCCION ......................................................................................................
CAPITULO I: AGENTE REFLEJO SIMPLE.............................................................
1.1 Definición ................................................................................................................
1.2 Representación del Ambiente ...................................................................................
1.3 Conocimiento Declarativo ........................................................................................
1.4 Conocimiento Procedural .........................................................................................
1.5 Código para Determinar el Desempeño del Agente...................................................
1.6 Ejemplo Desempeño del Agente................................................................................
1.7 Tabla Acción-Percepción ..........................................................................................
1.8 Análisis de Resultados .............................................................................................
CAPITULO II: AGENTE DE BÚSQUEDA...............................................................
2.1 Definición ...............................................................................................................
2.2 Estados....................................................................................................................
2.3 Criterio de Parada ...................................................................................................
2.4 Planteamiento del Problema ....................................................................................
2.5 Representación de Estados.......................................................................................
2.6 Operadores..............................................................................................................
2.7 Estado Inicial y Estado Meta...................................................................................
2.7.1 Agente BFS .................................................................................................
2.7.2 Agente DFS.................................................................................................
2.8 Resultado de Búsqueda............................................................................................
2.8.1 Agente BFS .................................................................................................
2.8.2 Agente DFS.................................................................................................
2.9 Análisis de Resultado..............................................................................................
CONCLUSIONES .......................................................................................................
RECOMENDACIONES..............................................................................................
BIBLIOGRAFIA..........................................................................................................
ANEXO ........................................................................................................................
INTELIGENCIA ARTIFICIAL 2

RESUMEN
El presente Informe final abarca el comportamiento del agente reflejo simple y
del agente de búsqueda donde se presenta los detalles del análisis, y operación
de estos agentes, que tiene como objetivo limpiar un ambiente aleatoriamente,
generando basura, obstáculos, wumpus esparcidos de manera aleatoria en el
ambiente.
Para lograr dicho objetivo el agente contara con un solo sensor de ambiente, lo
cual le permitirá percibir y efectuar las acciones permitidas. Se elaborara una
tabla de percepción-acción, otra especificación será que el agente se encuentre
con un hueco se termina la operación y en ese momento se podrá hacer la
evaluación de la eficiencia, así determinamos la eficiencia de los agentes.
INTELIGENCIA ARTIFICIAL 3

INTRODUCCIÓN
En el presente trabajo presentaremos el comportamiento de dos agentes el de
reflejo simple y el de búsqueda, cada uno capaz de realizar acciones de limpieza
cada vez que el mismo se topa con una porción de basura.
En la primera parte del trabajo se emplearon gráficos, con la finalidad de que
sea más entendible el comportamiento del agente simple, como por ejemplo la
representación del ambiente del agente, tablas de resultado y estadísticos para
dicho agente de igual manera las variables, estados y parámetros del agente.
Los cálculos que se muestran son complejidad y rendimiento del agente reflejo
simple.
En el siguiente capitulo se hará una breve descripción del Agente de Búsqueda
y como se podría implementar para la solución del problema propuesto en el
primer capitulo, a la vez también se realizará el cálculo de su complejidad y
rendimiento comparándose con el agente anterior propuesto en el primer
capítulo.
Al final se hará un breve análisis comparativo entre los agentes, con datos
obtenidos de las corridas, determinando la eficiencia de cada uno con respecto a
otro.
INTELIGENCIA ARTIFICIAL 4

CAPITULO I
AGENTE DE REFLEJO SIMPLE
1.1 DEFINICION
Este agente va a realizar tres tipos de movimientos que son avanzar, girar 90º a
la derecha y girar 90º a la izquierda. Los movimientos son determinados de
acuerdo a la percepción del ambiente en el que puede encontrar elementos
tales como basura, obstáculos y huecos. El accionar de estos agentes va a estar
determinado por la tabla Percepción-Acción.
1.2 REPRESENTACIÓN DEL AMBIENTE
Nuestro ambiente físico es una habitación en la cual se ubica el agente, el cual
tiene que aspirar la basura que encuentre durante su recorrido, esquivando los
posibles obstáculos que se presenten, así como las paredes que se encuentran
alrededor del ambiente, identificará cuáles son basuras que recogerá, no caer en
los obstáculos y evitar pasar dos veces por el mismo lugar.
PARED
AGUJERO
BASURAS
INTELIGENCIA ARTIFICIAL 5

AGENTE INTELIGENTE
1.3 CONOCIMIENTO DECLARATIVO
Encontramos diversas clases como esenciales e importantes como el ambiente,
el agente y la tabla de acción. Analizaremos cada clase:
public class Data {
String fileView = "/enviroment/view.txt"; // archivo view
String fileTable = "/enviroment/table.txt"; // archivo tabla
percepcion accion
Se extraen los archivos view y table que contienen los datos preliminares para la
implementacion de un agente simple.
Se asigna cada archivo a una variable String.
int view = {{0, 0, 0}, // view referencial
{0, 1, 0}, // lo que vale es lo que esta
{0, 0, 0}}; // en la tabla
Esto crea la vista de como empezara el agente simple o en que lugar empezara
el agente simple en el ambiente generado. Aquí es donde se puede cambiar el
tamaño de la matriz.
int table = {{0, 0, 0, 9, 1}, // tabla percepcion accion
{0, 0, 1, 9, 2}, // referencial
{1, 0, 0, 9, 4},
{0, 1, 0, 9, 5}};
Esto crea la secuencia o descripción de cada asignación de variables para el
applet.
Crea una matriz de enteros que contiene la descripción del ambiente del
agente.
public
String[]
readInput(String filename)
{
}
INTELIGENCIA ARTIFICIAL 6

Se crea un vector de datos.
Se declara un buffer de lectura de datos.
Se declara una cadena de texto para cada linea del archivo.
Se crea el buffer de lectura y se le asigna un archivo relacionado con el
parametro de entrada del nombre del archivo.
Mientas se lee cada linea del archivo incluido en el buffer, se asigna cada linea
al vector de datos.
Se cierra el buffer y se retorna el vector de datos con el tamaño asignado de
acuerdo a la cantidad de lineas en el archivo.
public void writeOutput(Vector out, String filename){
}
Se crea un vector de salida y se le asigna el vector de datos enviado como
parametro.
Ejecuta el metodo de escritura de salida enviandole el vector de datos y el
nombre del archivo.
public void writeOutput(String[] output, String filename) {
}
Se crea un objeto de escritura de archivos asignandole el nombre del archivo y
un indicador false.
Se crea un buffer de escritura y se le asigna el objeto de escritura de archivos.
Se crea una salida de archivos y se le asigna el buffer de escritura.
Se recorre el vector de datos enviado como parametro y muestra en pantalla el
contenido de cada posicion del vector.
Se cierra la salida de archivos.
private String getCurrentPath(){
}
Esto crea un vector de 3 X 3 para la creación del ambiente en donde interactuara
el agente simple.
}
public int[][] view() {
Se crea un vector entero de 3 X 3.
Se crea un vector string T que lee los datos de entrada #getCurrentPath()# y lee
el archive.
Mientras se recorre el vector string T, se crea el vector string s asignandole
elcontenido de cada una de las posiciones del vector T, y por cada elemento del
vector s se le asigna el contenido a la posicion respectiva del vector entero 3 x 3.
Retorna el vector de 3 X 3
INTELIGENCIA ARTIFICIAL 7

public int[][] table() {
}
Se crea una matriz de 99x5.
Se crea una variable de filas y se le asigna 0.
Se crea un vector T al que se le asigna el contenido del archivo filetable que
contiene la tabla de percepcion acción referencial.
Mientras se recorre el vector T, se evalúa si la posición del vector empieza con
"|" o con " "; si es true asigna el numero de posición a la variable de filas.
Se corta la rutina, se crea el vector S y se le asigna la posición actual del vector T
dividido con " ", mientras se recorren las posiciones del vector s, se le asigna a la
matriz table el contenido de la posicion actual del vector S.
Retorna el resultado del método copy enviándole la matriz table y la variable de
filas.
public void print(int[][] M) {
}
Se recorre un vector entero bidimensional con dos variables enteras para luego
imprimir la posición entre estos dos dejando un espacio en blanco.
public void print(String[] S) {
}
Se recorre un vector entero para luego imprimir cada uno de sus objetos.
public int[][] copy(int[][] M, int rows) {
}
Se reciben dos variables, una de ellas un vector entero bidimensional y una
variable entera.
Se crea un vector entero bidireccional y se le asigna los parámetros de las
variables recibidas.
Se crea una variable entera que recorre hasta llegar al limite da la variable rows
y almacena en el vector creado.
Retorna el vector creado.
public class Enviroment {
private int Mmin = 3, Mmax = 20;
protected int[][] Space;
protected Dimension Size;
protected Dimension Position;
private String Orientation = "";
private int Beated = 0;
private int EMPTY = 0; // vacio
private int WALL = 1; // pared
private int HOLE = 2; // hueco
private int TARGET = 9; // basura
private double pWall = 0.2; // porcentaje paredes
INTELIGENCIA ARTIFICIAL 8

private double pHole = 0.01; // porcentaje de huecos
private double pTarget = 0.2; // porcentaje de basuras
private int[][] View = {{0, 0, 0}, {0, 1, 0}, {0, 0, 0}};
protected String[] ORIENTATION = {"TOP", "LEFT", "DOWN", "RIGHT"};
En esta sección se declaran y se inicializan las variables que se usaran en la clase
Enviroment, se inicializan los porcentajes de las paredes, huecos, objetivos,
matriz de estado inicial, orientación, etc.
public Enviroment() {
View = (new Data()).view();
setEnviroment();
}
public Enviroment(int[][] view) {
SetViews(view);
setEnviroment();
}
public Enviroment(double wall, double hole, double target) {
SetPercentObjects(wall, hole, target);
setEnviroment();
}
public Enviroment(int[][] view, double wall, double hole, double target) {
SetPercentObjects(wall, hole, target);
SetViews(view);
setEnviroment();
}
Se describe el método constructor recibiendo diferentes parámetros para
inicializar las variables de entorno.
private void setEnviroment() {
Size = new Dimension();
Size.height = (int) (Mmin + (Mmax - Mmin) * Math.random());
Size.width = (int) (Mmin + (Mmax - Mmin) * Math.random());
Space = new int[Size.height + 2][Size.width + 2];
En esta sección del método se crea un objeto que representa las dimensiones a
usar en el ambiente, y se setean los respectivos valores del ancho y largo, así
como la matriz de espacios.
for (int r = 1; r < Size.height + 1; r++) {
for (int c = 1; c < Size.width + 1; c++) {
if (Math.random() < pWall) {
Space[r][c] = WALL;
}
if (Math.random() < pHole) {
Space[r][c] = HOLE;
}
if (Math.random() < pTarget) {
// coloca elementos
INTELIGENCIA ARTIFICIAL 9

}
}
Space[r][c] = TARGET;
En esta sección del método se recorren las posiciones del ancho y largo del
entorno y se asignan a la matriz de espacios los respectivos elementos de pared,
hueco y objetivo de acuerdo a los porcentajes definidos al comienzo de la clase.
for (int r = 0; r < Size.height + 2; r++) {
Space[r][0] = WALL;
Space[r][Size.width + 1] = WALL;
}
for (int c = 0; c < Size.width + 2; c++) {
Space[0][c] = WALL;
Space[Size.height + 1][c] = WALL;
}
// coloca el borde
// coloca el borde
Se colocan y asignan las paredes a los espacios que serán bordes.
Position = new Dimension();
Position.height = 1 + (int) ((Size.height) * Math.random());
Position.width = 1 + (int) ((Size.width) * Math.random());
Space[Position.height][Position.width] = 0; // siempre inicia en vacio
Orientation = ORIENTATION[(int) (3 * Math.random())];
Se asigna la posición inicial tomando como base la altura, el ancho y el método
que genera números aleatorios, también se asigna una orientación aleatoria
tomando como base el arreglo de orientaciones definidos al inicio de la clase y
multiplicándolo por 3 veces el número aleatorio generado.
public void SetPercentObjects(double wall, double hole, double target) {
pWall = wall;
pHole = hole;
pTarget = target;
}
En este método se asignan los porcentajes que representan a las paredes, huecos
y objetivos.
public int setAction(int[] action) {
Dimension pos = getPosition();
String ori=getOrientation();
//System.out.println(action);
Se obtiene la posición y la orientación.
if(action[0]==1){ //RECOGE
//int[][] env=getEnviroment();
System.out.println("parentEnviroment.setAction Regoger");
Space[pos.height][pos.width]=0;
INTELIGENCIA ARTIFICIAL 10

}
print();
Si la acción que se envía como parámetro es igual a 1, se recoge la basura y se
asigna 0 a la posición intersecada por el ancho y largo.
else
if(action[0]==0){ //FINALIZA
System.out.println("parentEnviroment.setAction Finaliza");
print();
Si la acción es 0, el agente finaliza su movimiento.
else
if(action[0]==2){ //GIRA+
System.out.println("parentEnviroment.setAction Gira+");
if(ori.equals("TOP")){
Position.height=pos.height+1;
Position.width=pos.width;
}else if(ori.equals("LEFT")){
Position.height=pos.height;
Position.width=pos.width+1;
}else if(ori.equals("DOWN")){
Position.height=pos.height-1;
Position.width=pos.width;
}else if(ori.equals("RIGHT")){
Position.height=pos.height;
Position.width=pos.width-1;
}
Evalúa el valor de la orientación, y de acuerdo a eso se le asignan nuevos
valores de la posición de la siguiente orientación.
}
if(ori.equals("TOP")){
Orientation="LEFT";
}else if(ori.equals("LEFT")){
Orientation="DOWN";
}else if(ori.equals("DOWN")){
Orientation="RIGHT";
}else if(ori.equals("RIGHT")){
Orientation="TOP";
}
print();
Evalúa el valor de la orientación y asigna el nuevo valor de la orientación de
acuerdo a la rotación.
else
if(action[0]==3){ //AVANZA
System.out.println("parentEnviroment.setAction Avanza");
INTELIGENCIA ARTIFICIAL 11

}
if(ori.equals("TOP")){
Position.height=pos.height-1;
Position.width=pos.width;
}else if(ori.equals("LEFT")){
Position.height=pos.height;
Position.width=pos.width-1;
}else if(ori.equals("DOWN")){
Position.height=pos.height+1;
Position.width=pos.width;
}else if(ori.equals("RIGHT")){
Position.height=pos.height;
Position.width=pos.width+1;
}
Si la acción es 3, se le asigna las nuevas posiciones para que el agente avance a
una nueva posición.
return 0; // continuan las iteraciones
}
public int[][] getPerception() {
int[][] percept = new int[3][3];
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 3; c++) {
int p = Space[Position.height + r - 1][Position.width + c - 1];
percept[r][c] = View[r][c] * p;
}
}
return percept;
}
Este método asigna los valores de la matriz View a la matriz de percepción, y
luego retorna la matriz de percepción para ser usada luego por los otros
métodos o clases.
public int getPerceptionOnly() {
return Space[Position.height][Position.width];
}
Este método obtiene el valor de la matriz de espacios correspondientes a las
posiciones de ancho y largo actuales.
public int[] getPerceptionHorizontal() {
int[][] percept = getPerception();
for (int r = 0; r < 3; r++) {
if (View[r][0] == 1 || View[r][1] == 1 || View[r][2] == 1) {
return percept[r];
}
}
return null;
}
public int[][] getPerceptionVertical() {
INTELIGENCIA ARTIFICIAL 12

}
int[][] percept = getPerception();
for (int c = 0; c < 3; c++) {
if (View[0][c] == 1 || View[1][c] == 1 || View[2][c] == 1) {
int[][] vpercept = {{percept[0][c]}, {percept[1][c]}, {percept[2][c]}};
return vpercept;
}
}
return null;
Estos dos métodos obtienen las percepciones horizontales y verticales.
public void print(int[][] M) {
for (int r = 0; r < M.length; r++) {
print(M[r]);
}
}
Este método recibe como parámetro una matriz y muestra en pantalla los
valores de esa matriz.
public void print(int[] M) {
for (int c = 0; c < M.length; c++) {
System.out.print(M[c] + " ");
}
System.out.println(" ");
}
Este método recibe como parámetro un arreglo unidimensional y muestra en
pantalla los valores de este.
public void print() {
print(Space);
System.out.println("Dimension = [" + Size.height + "] [" + Size.width + "]");
System.out.println("Position = [" + Position.height + "] [" + Position.width + "]");
System.out.println("Orientation= [" + Orientation + "]");
System.out.println("View:");
print(View);
}
Este método muestra en pantalla, la dimension, la posición y orientación.
public Dimension getSize() {
return Size;
}
public Dimension getPosition() {
return Position;
}
public int[][] getEnviroment() {
return Space;
}
INTELIGENCIA ARTIFICIAL 13

public String getOrientation() {
return Orientation;
}
public String getOrientations() {
return Orientation;
}
public int getBeated() {
return Beated;
}
Estos métodos obtienen el tamaño, la posición, la matriz del entorno, la
orientación y la propiedad de golpe.
public void setBeated(int beated) {
Beated = beated;
}
Este método asigna el valor de la propiedad de golpe basándose en el
parámetro enviado.
static int sign(int view, int value) {
if (view < 0) {
return -1;
} else {
return value;
}
}
A este metodo se le envia dos enteros y retorna el valor de acuerdo al signo de
la variable view.
static int action(int action) {
return 0;
}
Este metodo retorna 0.
public static void main(String[] args) {
int[][] view = {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
Enviroment E = new Enviroment(view);
E.print();
E.getPerception();
}
Este es el método principal que inicializa la matriz view con 1 en todas sus
posiciones, crea el entorno enviando la matriz view, y obtiene la percepción del
entorno respectivo.
package agent;
import enviroment.*;
import gui.*;
INTELIGENCIA ARTIFICIAL 14

public class reflexAgent {
public int[][] table; // tabla percepción acción
public double[][] statistics; // estadisticas
public Enviroment Envirom; // medio ambiente
public Visual GUI; // applet
private double SLEEP = 0.25; // número máximo de pasos a procesar
private int MAXSTEPS = 100; // número máximo de pasos a procesar
public int step = -1; // ciclo actual
public static int targets=0;
int golpe=0;
/*
* Estadisticas
*/
static int egolpe=0;
static int eavanza=0;
static int ebasura=0;
static int ehueco=0;
static int cont=0;
static int limit=50;
Lo primero que se hizo es importar las clases enviroment y gui, son las clases
que nos determinan el entorno variable.
En esta sección se declaran y se inicializan las variables que se usaran en la clase
reflexAgent, se inicializan el número mínimo de pasos que el agente está
dormido, el numero máximo de pasos que realizara el agente, las entradas y el
golpe; además de inicializar las variables estáticas enteras para contar las
estadísticas del agente como: el golpe, cuantas veces avanza, la cantidad de
basura, la cantidad de huecos, un contador y limite de termino propuesto.
public reflexAgent(int maxstep, double sleep) {
table = (new Data()).table(); // lee la tabla percepción acción
Envirom = new Enviroment(); // crea el medio ambiente
MAXSTEPS = maxstep;
SLEEP = sleep;
}
public void setGUI(Visual gui) {
GUI = gui;
}
Se describe el método constructor recibiendo diferentes parámetros para
inicializar las variables del agente reflejo.
public int[][] interpretPercept(int[][] p) {
int ori = 0;
System.out.println("golpe"+golpe);
if(p[0][0] ==9){
//Existe basura
System.out.println("reflexAgent.interpretPercept Basura");
ebasura++;
int[][] vectorPerseccion = {{1,0,0,ori}}; //{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}else if(p[0][0] ==2){
//Hueco
System.out.println("reflexAgent.interpretPercept Hueco");
INTELIGENCIA ARTIFICIAL 15

ehueco++;
int[][] vectorPerseccion = {{0,1,0,ori}}; //{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}else if(p[0][0] ==1){
//Pared
System.out.println("reflexAgent.interpretPercept Pared");
egolpe++;
int[][] vectorPerseccion = {{0,0,1,ori}}; //{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}
}
else if(p[0][0] ==0 && golpe==0){ //Libre sin golpe
System.out.println("reflexAgent.interpretPercept Libre sin golpe");
eavanza++;
int[][] vectorPerseccion = {{0,0,0,ori}}; //{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}
return null;
En este método se describe la percepción del agente sobre su entorno, donde se
describirá como basura cuando es igual a 9 se cuenta cuantas basuras hay, como
hueco cuando es igual a 2 se cuenta cuantos huecos hay, pared cuando es igual
a 1 se cuenta cuantas veces choca, y si es igual a cero y no existe golpe se
cuentas veces avanza el agente. (Este método nos sirve para realizar el conteo
de las estadísticas que necesitamos)
public int[] findAction(int[][] p) {
}
if(p[0][0] ==1){
System.out.println("reflexAgent.findAction Recoge");
int[] action={1};
return action; //Recoge
}else if(p[0][1] == 1){
System.out.println("reflexAgent.findAction Finaliza");
int[] action={0}; //Finaliza
return action;
}else if(p[0][2] == 1){
System.out.println("reflexAgent.findAction Gira +");
int[] action={2}; //Gira +
return action;
}else {
System.out.println("reflexAgent.findAction Avanza");
int[] action={3}; //Avanza
return action;
}
Este método está relacionado con el anterior, porque cuando el anterior percibe
el estado actual del agente frente al ambiente lo que establece este método es la
acción a realizar frente a la percepción obtenida del método anterior.
public void setStatistics() {
INTELIGENCIA ARTIFICIAL 16

System.out.println("######### ESTADISTICOS ##########");
System.out.println("Complejidad del agente: "+(ebasura+eavanza+egolpe+ehueco));
int reglas=0;
if(egolpe != 0){reglas++;} //gira
if(eavanza != 0){reglas++;} //avanza
if(ebasura != 0){reglas++;} //Recoge
if(ehueco != 0){reglas++;} //Finaliza
System.out.println("Nro reglas que a usado mas de una vez : "+reglas);
System.out.println("Nro de veces que el agente Avanza: "+eavanza);
System.out.println("Nro de veces que el agente Gira + o - : "+egolpe);
System.out.println("Nro de veces que el agente se Golpea: "+egolpe);
System.out.println("Nro de veces que el agente recoge Basura: "+ebasura);
}
double edesempeño =((double)ebasura/(double)targets)*100;
System.out.println("Desempeño: "+edesempeño+"%");
System.out.println("Nro de Basura existente en el Ambiente: "+targets);
Este método nos muestra las estadísticas como: la complejidad, el número de
reglas utilizadas, el número de veces que el agente avanza, el número de veces
que el agente gira, el número de veces que el agente golpea, el número de
basuras, el desempeño y el numero de basuras totales.
public boolean stopCondition() {
boolean stop = true;
if(cont>=limit){
stop = false; }
cont++;
return stop; }
Este método permite parar la iteración del agente cuando el contador supera el
limite estimado que anteriormente pusimos en la clase reflexAgent.
public boolean cycling() {
// retornar false si aún no se ha ciclado
// retornar true si se ha ciclado
return false;
}
Este método nos dice si se ha producido un ciclado o no.
public static void main(String[] args) {
String pathFile = "E:/web1/courses/intelligent_systems/ST414/2008-
II/java/Agent/src/enviroment";
reflexAgent A = new reflexAgent(20, 0.25);
// el main permite instanciar la clase pero no se ejecuta
// correr el programa Visual
}
}
Este método nos permite correr el programa
INTELIGENCIA ARTIFICIAL 17

1.4 CONOCIMIENTO PROCEDURAL
INICIO
Inicializa variables fileView y
fileTable que contienen los
nombres de los archivos view y
table.
Inicializa matrices view y table con
el contenido de los archivos
fileView y fileTable.
Inicializa matrices view y table con
el contenido de los archivos
fileView y fileTable.
INTELIGENCIA ARTIFICIAL 18

Public String[] readInput(String filename)
{
Se crea un vector de datos.
Se declara un buffer de lectura de
datos.
Se declara una cadena de texto para
cada línea del archivo.
Se crea el buffer de entrada
asignándole el archivo enviado
como parámetro.
Se crea el buffer de entrada
asignándole el archivo enviado
como parámetro.
Mientras la línea
leída del archivo n
osea nula.
Se añade la línea leída del
archivo al vector
Retornar vector de datos
INTELIGENCIA ARTIFICIAL 19

public void writeOutput(Vector out, String filename)
{
Se crea un vector de salida
y se le asigna el vector de
datos enviado como
parámetro.
Ejecuta el método de escritura
de salida enviándole el vector de
datos y el nombre del archivo.
Se crea un objeto de escritura
de archivos asignándole el
nombre del archivo y un
indicador false.
Se crea un buffer de escritura
y se le asigna el objeto de
escritura de archivos.
Se crea una salida de archivos
y se le asigna el buffer de
escritura.
Desde la posición 0 hasta el
tamaño de la salida de
archivos, incrementándose
la posición en 1
Muestra en pantalla el contenido
de cada posición del vector.
Cierra la salida de archivos.
INTELIGENCIA ARTIFICIAL 20

public int[][] view() {
}
Crea un vector entero de 3 X 3 y
crea un vector string T
Lee el archivo
Desde la posición 0 hasta el tamaño
de la salida de archivos,
incrementándose la posición en 1
Se crea el vector string s asignandole
elcontenido de cada
una de las posiciones del vector T
Desde la posición 0 hasta el tamaño
de la salida de archivos,
incrementándose la posición en 1
Al vector s se le asigna el contenido
a la posicion respectiva del vector entero
de 3x3
Retorna el vector de 3 X 3
INTELIGENCIA ARTIFICIAL 21

public int[][] table() {
Se crea una matriz de 99x5 y una variable
de filas donde se le asigna 0.
Se crea un vector T al que se le asigna el
contenido del archivo filetable que
contiene la tabla de percepcion acción
referencial.
Desde la posición 0 hasta el tamaño
de la salida de archivos,
incrementándose la posición en 1
Si la posición del vector
empieza con "|" o con " ";
Si es true asigna el numero de
posición a la variable de filas.
Se corta la rutina de ejecución de la
sentencia if.
Se crea el vector S y se le asigna la
posición actual del vector T dividido
con " "
INTELIGENCIA ARTIFICIAL 22

Se recorren las posiciones del
vector S desde la posición 0 hasta el
tamaño de la salida de archivos,
incrementándose la posición en 1
Se le asigna a la matriz table el
contenido de la posicion actual del
vector s.
Retorna el resultado del metodo copy
enviandole la matriz table y la variable
de filas
INTELIGENCIA ARTIFICIAL 23

public class Enviroment {
Se declara y se inicializan las
variables
Se inicializa los porcentajes de las
paredes, huecos, objetivos, matriz de
estado inicial, orientación, etc.
private void setEnviroment() {
Se crea un objeto que representa las
dimensiones a usar en el ambiente.
Se setean los respectivos valores de
ancho y largo, así como la matriz de
espacios.
Se recorre las
posiciones del
ancho y largo del
entorno
Si
Si Math.random() < pWall
No
Space[r][c] = WALL
Si
Si Math.random() < pHole
Spacer[r][c] = HOLE
Si
Si Math.random() < pTarget
Spacer[r][c] = TARGET
INTELIGENCIA ARTIFICIAL 24

Se recorre las
posiciones del
ancho y largo del
entorno
Se colocan y asignan las paredes a
los espacios que serán bordes.
Se asigna la posición inicial tomando
como base la altura, el ancho y el
método que genera números aleatorios
se asigna una orientación aleatoria
tomando como base el arreglo de
orientaciones definidos al inicio de la
clase y multiplicandolo por 3 veces el
número aleatorio generado.
public void SetPercentObjects(double wall, double hole, double target) {
Se declaran las variables wall, hole,
target
Se asignan los porcentajes que
representan a las paredes, huecos y
objetivos.
public int setAction(int[] action) {
Se declara la matriz action
Se obtiene la posición y la
orientación
INTELIGENCIA ARTIFICIAL 25

public int setAction(int[] action) {
Se declara la matriz action
Se obtiene la posición y la
orientación
Si la acción que envía
como parámetro es igual a
1
se recoge la basura y se asigna 0 a la
posición intersecada por el ancho y
largo
Si la acción que envía
como parámetro es igual a
0
Finaliza su movimiento
Si la acción que envía
como parámetro es igual a
2
Evalúa el valor de la orientación, y de
acuerdo a eso se le asignan nuevos
valores de la posición de la siguiente
orientación.
INTELIGENCIA ARTIFICIAL 26

Si la acción que envía
como parámetro es igual a
3
se le asigna las nuevas posiciones
para que el agente avance a una
nueva posición
Retorna percepcion
static int sign(int view, int value) {
Se declara las variables
view y value
public static void main(String[] args) {
se le envia dos enteros y
retorna el valor de acuerdo al
signo de la variable view
Se declara una matriz
Se inicializa la matriz view
con 1 en todas sus
posiciones.
public class reflexAgent {
Se crea el entorno enviando
la matriz view, y obtiene la
percepción del entorno
respectivo.
INTELIGENCIA ARTIFICIAL 27

Se importa las clases
enviroment y gui
Se declara y se inicializa las
variables que usará la clase
reflexAgent.
Se inicializa el número mínimo
de pasos que el agente está
dormido, el numero máximo de
pasos que realizara el agente,
las entradas y el golpe .
Se inicializa las variables
estáticas enteras para contar
las estadísticas del agente
public int[][] interpretPercept(int[][] p) {
Se declara la matriz p
Si la matriz p es igual
a 9
Contar cuantas basuras hay
Si la matriz p es
igual a 2
Contar cuantas huecos
hay
Si la matriz p es
igual a 1
Cuenta cuantas veces choca
con pared.
Si la matriz p es
igual a 0
Cuenta cuantas veces
avanza el agente.
public void setStatistics() {
INTELIGENCIA ARTIFICIAL 28

Se declara la variable regla
Si la variable regla es
igual a cero.
Se cuenta cuantas reglas hay
Se visualiza en pantalla el
número de reglas usadas.
Si la estadistica
golpe es diferente de
cero
Se cuenta cuantos golpes hay
Se visualiza en pantalla el
número de golpes.
Si la estadistica
avanza es diferente
de cero
Se cuenta cuantos veces
avanza.
Se visualiza en pantalla el
número de veces que avanza.
INTELIGENCIA ARTIFICIAL 29

Si la variable
estadistica basura es
diferente de cero
Se cuenta cuantas reglas hay
Se visualiza en pantalla el número
de basura que recoge.
Se halla el porcentaje de
desempeño
Se visualiza en pantalla el
porcentaje de desempeño del
agente.
Se visualiza en pantalla el
número de basura en el
ambiente
public boolean stopCondition() {
Se declara la variable stop
como verdadera
Si el contador es mayor
o igual al límite
Stop = falso;
Cont++
INTELIGENCIA ARTIFICIAL
Retorna la variable stop
30

public static void main(String[] args) {
Se instancia la clase main
Se corre el programa.
1.5 CODIGO PARA DETERMINAR EL DESEMPEÑO DEL AGENTE
package agent;
import enviroment.*;
import gui.*;
public class reflexAgent {
public int[][] table;
acción
public double[][] statistics;
public Enviroment Envirom;
public Visual GUI;
private double SLEEP = 0.25;
pasos a procesar
private int MAXSTEPS = 100;
pasos a procesar
public int step = -1;
public static int targets=0;
int golpe=0;
// tabla percepción
// estadisticas
// medio ambiente
// applet
// número máximo de
// número máximo de
// ciclo actual
/*
* Estadisticas
*/
static int egolpe=0;
static int eavanza=0;
static int ebasura=0;
static int ehueco=0;
static int cont=0;
INTELIGENCIA ARTIFICIAL 31

static int limit=50;
Lo primero que se hizo es importar las clases enviroment y
gui, son las clases que nos determinan el entorno variable.
En esta sección se declaran y se inicializan las variables
que se usaran en la clase reflexAgent, se inicializan el
número mínimo de pasos que el agente esta dormido, el
numero máximo de pasos que realizara el agente, las
entradas y el golpe; además de inicializar las variables
estáticas enteras para contar las estadísticas del agente
como: el golpe, cuantas veces avanza, la cantidad de
basura, la cantidad de huecos, un contador y limite de
termino propuesto.
public reflexAgent(int maxstep, double sleep) {
table = (new Data()).table(); // lee la tabla
percepcion accion
Envirom = new Enviroment(); // crea el medio
ambiente
}
MAXSTEPS = maxstep;
SLEEP = sleep;
public void setGUI(Visual gui) {
GUI = gui;
}
Acá se describe el método constructor recibiendo
diferentes parámetros para inicializar las variables del
agente reflejo.
public int[][] interpretPercept(int[][] p) {
int ori = 0;
System.out.println("golpe"+golpe);
if(p[0][0] ==9){
//Existe
basura
System.out.println("reflexAgent.interpretPercept
Basura");
ebasura++;
int[][] vectorPerseccion = {{1,0,0,ori}};
//{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}else if(p[0][0] ==2){
//Hueco
System.out.println("reflexAgent.interpretPercept
Hueco");
ehueco++;
INTELIGENCIA ARTIFICIAL 32

int[][] vectorPerseccion = {{0,1,0,ori}};
//{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}else if(p[0][0] ==1){
//Pared
System.out.println("reflexAgent.interpretPercept
Pared");
egolpe++;
int[][] vectorPerseccion = {{0,0,1,ori}};
//{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}
else if(p[0][0] ==0 && golpe==0){ //Libre
sin golpe
System.out.println("reflexAgent.interpretPercept
Libre sin golpe");
eavanza++;
int[][] vectorPerseccion = {{0,0,0,ori}};
//{{basura,hueco,golpe,orientacion}}
return vectorPerseccion;
}
return null;
}
En este método se describe la percepción del agente sobre
su entorno, donde se describirá como basura cuando es igual
a 9 se cuenta cuantas basuras hay, como hueco cuando es
igual a 2 se cuenta cuantos huecos hay, pared cuando es
igual a 1 se cuenta cuantas veces choca, y si es igual a
cero y no existe golpe se cuentas veces avanza el agente.
(Este método nos sirve para realizar el conteo de las
estadísticas que necesitamos)
public int[] findAction(int[][] p) {
if(p[0][0] ==1){
System.out.println("reflexAgent.findAction
Recoge");
int[] action={1};
return action; //Recoge
}else if(p[0][1] == 1){
System.out.println("reflexAgent.findAction
Finaliza");
int[] action={0}; //Finaliza
return action;
}else if(p[0][2] == 1){
System.out.println("reflexAgent.findAction Gira
+");
int[] action={2}; //Gira +
INTELIGENCIA ARTIFICIAL 33

eturn action;
}else {
System.out.println("reflexAgent.findAction
Avanza");
int[] action={3}; //Avanza
}
}
return action;
Este método esta relacionado con el anterior, porque cuando
el anterior percibe el estado actual del agente frente al
ambiente lo que establece este método es la acción a
realizar frente a la percepción obtenida del método
anterior.
public void setStatistics() {
System.out.println("######### ESTADISTICOS
##########");
System.out.println("Complejidad del agente:
"+(ebasura+eavanza+egolpe+ehueco));
int reglas=0;
if(egolpe != 0){reglas++;} //gira
if(eavanza != 0){reglas++;} //avanza
if(ebasura != 0){reglas++;} //Recoge
if(ehueco != 0){reglas++;} //Finaliza
System.out.println("Nro reglas que a usado mas de una
vez : "+reglas);
System.out.println("Nro de veces que el agente Avanza:
"+eavanza);
System.out.println("Nro de veces que el agente Gira +
o - : "+egolpe);
System.out.println("Nro de veces que el agente se
Golpea: "+egolpe);
System.out.println("Nro de veces que el agente recoge
Basura: "+ebasura);
double edesempeño
=((double)ebasura/(double)targets)*100;
System.out.println("Desempeño: "+edesempeño+"%");
System.out.println("Nro de Basura existente en el
Ambiente: "+targets);
}
Este método nos muestra las estadísticas como: la
complejidad, el número de reglas utilizadas, el número de
veces que el agente avanza, el número de veces que el
agente gira, el número de veces que el agente golpea, el
número de basuras, el desempeño y el numero de basuras
totales.
AQUÍ ES DONDE
SALEN LAS
ESTADISITICAS
INTELIGENCIA ARTIFICIAL 34

public boolean stopCondition() {
boolean stop = true;
if(cont>=limit){
stop = false; }
cont++;
return stop; }
Este método permite parar la iteración del agente cuando el
contador supera el limite estimado que anteriormente
pusimos en la clase reflexAgent.
public boolean cycling() {
// retornar false si aún no se ha ciclado
// retornar true si se ha ciclado
return false;
}
Este método nos dice si se ha producido un ciclado o no.
public void run() {
//reflexAgent Agent;// percepcion leída por los
sensores
int[][] state;
// percepción
transformada para ser usada por P->A
int[] action;
// acción a ejecutarse
while (stopCondition()) {
int[][]percept =
{{Envirom.getPerceptionOnly()}};//Saca la percepcion de 1x1
System.out.println(Envirom.getPerceptionOnly());
try{
state = interpretPercept(percept);//Vector
Percepcion
action = findAction(state);//Reglas
if(action[0]==0){
break;
}
Envirom.setAction(action);//Hace el
movimiento
GUI.paint(GUI.getGraphics());
// vuelve a pintar el ambiente
Wait.manySec(SLEEP);
}catch (Exception e) {
e.printStackTrace();
}
// espera 1/4 de segundo
INTELIGENCIA ARTIFICIAL 35

}
}
setStatistics();
public static void main(String[] args) {
String pathFile =
"E:/web1/courses/intelligent_systems/ST414/2008-
II/java/Agent/src/enviroment";
reflexAgent A = new reflexAgent(20, 0.25);
// el main permite instanciar la clase pero no se
ejecuta
// correr el programa Visual
}
}
Este método nos permite correr el programa
INTELIGENCIA ARTIFICIAL 36

1.6 EJEMPLO DEL DESEMPEÑO DEL AGENTE
INTELIGENCIA ARTIFICIAL 37

1.7 TABLA ACCION-PERCEPCION
Estadisticas del Agente Reflejo Simple 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Complejidad del agente 50 50 50 50 50 50 37 50 50 50 50 50 50 50 50 50
Nro reglas que a usado mas de una vez : 2 3 3 3 3 3 4 3 3 3 3 3 3 3 3 3
Nro de veces que el agente Avanza: 33 40 36 33 40 38 24 38 39 35 40 38 32 37 37 39
Nro de veces que el agente Gira -: 5
Nro de veces que el agente Gira + : 17 12 16 7 9 5 5 8 13 9 7 16 12 9 10
Nro de veces que el agente se Golpea: 17 5 12 13 5 7 6 4 9 14 6 5 14 12 6 9
Nro de veces que el agente recoge Basura: 0 5 2 1 3 3 7 7 3 2 1 5 2 1 4 1
Calcule el desempeño del agente 0% 20.83% 16.67% 10% 8.57% 8.33% 18.92% 30.43% 13.04% 7.69% 33.33% 38.46% 100% 4.54% 133.33% 16.67%
¿El agente retorna a su posicion inicial? NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO
Diga si la trayectoria del agente cruza con la del otro agente NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO
El medio ambiente es dinamico NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO
El medio ambiente es episodico NO SI NO NO SI NO SI NO NO NO NO NO NO NO NO NO
INTELIGENCIA ARTIFICIAL 38

1.8 ANÁLISIS DE LOS RESULTADOS
DESEMPEÑO VS COMPLEJIDAD
80
70
60
50
DESEMPEÑO
40
30
20
10
0
0% 50% 100% 150% 200% 250%
COMPLEJIDAD
AMBIENTE VS COMPLEJIDAD
80
70
60
50
COMPLEJIDAD
40
30
20
10
0
0 50 100 150 200 250 300 350 400
AMBIENTE
DESEMPEÑO VS AMBIENTE
250%
200%
DESEMPEÑO
150%
100%
50%
0%
0 50 100 150 200 250 300 350 400
CAPITULO II
AMBIENTE
INTELIGENCIA ARTIFICIAL 39

AGENTE DE BÚSQUEDA
2.1 DEFINICIÓN DEL AMBIENTE
Este agente tiene la habilidad de observar completamente el Medio Ambiente,
se caracteriza por resolver problemas de planificación. Para nuestro caso hemos
planteado como podemos limpiar la totalidad de basuras en el ambiente
utilizando el menor número de recursos.
2.2 ESTADOS
2.2.1 Estado Inicial
El estado padre va ser como va estar configurado el medio ambiente en el
momento inicial, antes de haber realizado cualquier operación o que los
sensores hayan detectado algo.
2.2.2 Estado Meta
No existe ya que no sabemos con exactitud como estará el estado final
distribuido.
2.3 CRITERIO DE PARADA
El sistema no permite realizar más de 50 iteraciones. Si el agente percibe un
HUECO se apaga
2.4 PLANTEAMIENTO DEL PROBLEMA
• Se tiene un ambiente, compuesto por filas y columnas, estas serán
ingresadas al azar.
• Lo que se requiere es un agente que se comporte como una aspiradora,
cuyos objetivos es movilizarse por todo el ambiente y limpiar toda la
basura que encuentre a su paso.
INTELIGENCIA ARTIFICIAL 40

• El ambiente en el que se encontrará el Agente contará no sólo con basura
sino también con obstáculos y huecos, los cuales deberá ser capaz de
superar o evitar para lograr su meta.
2.5 REPRESENTACIÓN DE ESTADOS
PARED
AGUJERO
BASURAS
2.6 OPERADORES
AGENTE INTELIGENTE
//OPERADORES AGENTES DE BUSQUEDA
public final static int MOVER_DERECHA = 0;
public final static int MOVER_ABAJO = 1;
public final static int MOVER_IZQUIERDA = 2;
public final static int MOVER_ARRIBA = 3;
public final static int BASURA = 1;
public final static int OBSTACULO = 2;
public final static int PARED = 2;
public final static int PAREDES = 2;
public final static int HUECO = 3;
public final static int AGENTE = 5;
//VALORES PARA ORIENTACION DEL AGENTE
public final static int NORTE = 1;
public final static int ESTE = 2;
public final static int SUR = 3;
public final static int OESTE = 4;
//ACCIONES
public final static int ROTAR_90_POS = 1;
public final static int ROTAR_90_NEG = 2;
public final static int SUCCIONAR = 3;
public final static int AVANZAR = 4;
public final static int PARAR = 5;
//MATRIZ DE PERCEPCION
public final static int SENSOR_GOLPE = 0;
public final static int SENSOR_ORIGEN = 1;
public final static int SENSOR_BASURA = 2;
public final static int SENSOR_HUECO = 3;
public final static int SENSOR_ORIENTACION = 4;
INTELIGENCIA ARTIFICIAL 41

VALORES GUARDADOS EN MEMORIA
public final static int LIBRE = 0;
public final static int GOLPE = 1;
//TIPOS DE BUSQUEDA
public final static int BFS = 0;
public final static int DFS = 1;
2.7 ESTADO INICIAL Y ESTADO META
2.7.1 AGENTE BFS
2.7.2 AGENTE DFS
INTELIGENCIA ARTIFICIAL 42

2.8 RESULTADO DE BÚSQUEDA
2.8.1 AGENTE BFS
INTELIGENCIA ARTIFICIAL 43

2.8.2 AGENTE DFS
2.9 ANÁLISIS DE RESULTADO
El método BFS al momento de recorrer para buscar la mejor solución se demora
demasiado, por eso un poco mas efectivo es el método DFS que la demora es
menor.
INTELIGENCIA ARTIFICIAL 44

CONCLUSIONES
- La complejidad de cada agente aumenta en la medida de su ambiente
generado; el hecho de ser aleatorio implica la posibilidad de que el agente se
encuentre en un determinado momento dentro de un campo cerrado y no
logre salir de él.
- El mejor rendimiento del agente se dará a medida que vayamos mejorando
el algoritmo que debe seguir.
- El rendimiento del agente es 0 si el agente no llego a limpiar toda la basura
del ambiente y el rendimiento es 100 si el agente cumplio en limpiar toda
basura del ambiente.
- El desempeño del agente sera el resultado de calcular el numero de basura
limpiada / numero total de basura en el ambiente; todo esto por 100. Con lo
cual se obtiene el porcentaje.
- El agente reflejo simple no puede recordar su pasado, en la cual no conserva
ningún estado anterior, todas las acciones lo hace mediante las percepciones
de ese instante.
- El agente reflejo simple tiene una dependencia total al guiar sus acciones de
una tabla percepción-acción hecha por los creadores
INTELIGENCIA ARTIFICIAL 45

RECOMENDACIONES
Se recomienda tener un código fuente bien ordenado para que la
comprensibilidad del programa sea más rápido y a su vez, dará facilidad para
futuras modificaciones de dicho programa.
Debe realizarse pruebas prácticas en busca de las tablas de percepción – acción,
la elección de las opciones más óptimas, tienen como desencadenante el
conseguir mayor rendimiento del agente.
Debe elegirse el agente adecuado para la tarea adecuada ya que cuando uno se
equivoca representa un gasto enorme de recursos y la muy poca probabilidad
de conseguir objetivos.
Se debe de obtener modelos similares para que se pueda comparar con el
modelo principal.
INTELIGENCIA ARTIFICIAL 46

REFERENCIAS BIBLIOGRAFICAS
http://saevius.iespana.es/descargas/Investigacion/Agentes/RESUMEN%20A
GENTES.pdf
http://www.cruzrojaguayas.org/inteligencia/Estructura%20de%20Agentes%2
0Inteligentes.htm
http://www.angelfire.com/falcon/popikpe/cap_dos.htm
ANEXO
SE UTILIZO EL CODIGO ANTERIOR DEL GRUPO Nº 4 – 2008 – I NOMBRES:
Breña Lora Erik; Farfán Rosas Miguel Ángel; Hidalgo Cárdenas
Claudia Carolina; Perea Isasi Cinthya Paola; Pichilingue Rios Giuliana
Miguelina; Ramos Caballero Arturo; Vicuña Solórzano Suzanne
Giuliana.
En base al trabajo que se hace referencia se realizo las siguientes
modificaciones para la asignación de las variables de filas, columnas y
nodos sean asignadas a gusto interesado.
INTELIGENCIA ARTIFICIAL 47

se cambio de variable private a public para que se ha reconocido por el frmagente
public static void calcularEstadisticas(BFS busqueda) {
Se creo este método para guardar el número de filas y
columnas obtenidas del frmagente
public BFS(int nroFilas, int nroColumnas){
}
filasTotal = nroFilas;
columnasTotal = nroColumnas;
Se creo este método para que no exista ninguna referencia
al método anterior public BFS(Estado inicio, Estado meta,
int nodos) { y no existan falsas llamadas al método.
public void AsignarEstadosNodos(Estado inicio, Estado meta, int nodos){
estadoInicio = inicio;
estadoMeta = meta;
maximoNodosAbiertos = nodos;
abiertos = new Vector();
cerrados = new Vector();
arbolBusqueda = new Arbol("Búsqueda BFS"); // CREA EL ARBOL BFS
nodoHijo = new Nodo(estadoInicio); // INSTANCIA EL PRIMER NODO
arbolBusqueda.insertarAlFrente(nodoHijo); //ADICIONAR NODO AL
ARBOL
}
abiertos.addElement(estadoInicio); // AGREGA NODO A LOS NODOS
ABIERTOS
INTELIGENCIA ARTIFICIAL 48

private JButton getBtnCrearAgenteBusqueda() {
if (btnCrearAgenteBusqueda == null) {
btnCrearAgenteBusqueda = new JButton();
btnCrearAgenteBusqueda.setBounds(new Rectangle(150, 150, 199, 27));
btnCrearAgenteBusqueda.setText("Crear agente de busqueda");
btnCrearAgenteBusqueda.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent e) {
System.out.println("actionPerformed()"); // TODO Auto-generated Event stub
actionPerformed()
Se recibe los valores insertados por el usuario y se guardan en nroFilas y
nroColumnas
int nroFilas = Integer.parseInt(txtNroFilas.getText()) + Constantes.PAREDES;
int nroColumnas =Integer.parseInt(txtNroColumnas.getText()) +
Constantes.PAREDES;
Se envían las variables al método constructor de la clase BFS.
BFS agenteBusqueda = new BFS(nroFilas,nroColumnas);
MedioAmbiente ma = new
MedioAmbiente(nroFilas,nroColumnas);
int[][] mm1 = ma.getAmbiente(); //GUARDA ESTADO
INICIAL EN UNA NUEVA VARIABLE
int[][] mm2 = ma.getAmbienteFinal(); //GUARDA
ESTADO META EN UNA NUEVA VARIABLE
System.out.println("NUMERO DE BASURAS : " +
ma.getNumBasuras());
INTELIGENCIA ARTIFICIAL 49

int nroBasuras = ma.getNumBasuras();
agenteBusqueda.basuras = nroBasuras;
System.out.println("");
System.out.print("ESTADO INICIAL | ");
System.out.println("ESTADO META");
Estado SS = new Estado(mm1); //INICIALIZA UNA INSTANCIA DE UN
ESTADO EN BASE AL ESTADO INICIAL
Estado GS = new Estado(mm2); //INICIALIZA UNA INSTANCIA DE UN
ESTADO EN BASE AL ESTADO META
agenteBusqueda.AsignarEstadosNodos(SS, GS,
Integer.parseInt(txtNroNodos.getText()));
Vector path = agenteBusqueda.busquedaBFS();
System.out.println("================================");
System.out.println("=====SE ALCANZÓ ESTADO META=====");
System.out.println("================================");
System.out.println("RUTA");
System.out.println("=====");
agenteBusqueda.imprimirRuta(path);
BFS.calcularEstadisticas(agenteBusqueda);
}
});
}
return btnCrearAgenteBusqueda;
}
INTELIGENCIA ARTIFICIAL 50