Aplicación de los algoritmos de hormigas para la resolución del problema de equilibrado de líneas

de montaje SALBP-E y aplicación a un caso real – Anexo IV: Listado del programa

Javier Bretón Blas y Jose Antonio Fernández Ros

SW-122/2010

(CN 2010-BF)

Publica: Universitat Politècnica de Catalunya www.upc.edu

Edita:

Cátedra Nissan www.nissanchair.com

director@nissanchair.com

Departamento de Organización de Empresas

Universidad Politécnica de Cataluña

Cátedra Nissan -PROTHIUS-

TiTOL

ALUMNE

ASSIGNATURA

PROFESSOR

DATA

DOCUMENT

Aplicación de los algoritmos de hormigas para la resolucióndel problema de equilibrado de líneas de montaje SALBP-E yaplicación a un caso real.

Javier Bretón Blas; Jose Antonio Fernández Ros

Proyecto final del carrera

D. Joaquín Bautista Valhondo

4 de octubre de 2000

Anexo lV: Listados del programa

RESUM Este anexo incluye el código fuente en Java de las aplicacionesinformáticas implementadas para el algoritmo de hormigas sinmejora, el algoritmo de hormigas con mejora y el multi-start, asícomo la descripción funcional de los objetos que las forman.

ESCOLA TÉCNICA SUPERIOR D'ENGINYERIA INDUSTRIAL - BARCELONA

i

ÍNDICE

RESUMEN................................................................................................................................ 1

CAPÍTULO 1: ALGORITMO DE HORMIGAS................................................................... 2 1.1 DESCRIPCIÓN DEL PROGRAMA ....................................................................................... 3 1.2 LISTADO DE LOS OBJETOS .............................................................................................. 5

CAPÍTULO 2: ALGORITMO DE LAS HORMIGAS CON MEJORA LOCAL............. 58 2.1 DESCRIPCIÓN DEL PROGRAMA ..................................................................................... 59 2.2 LISTADO DE LOS OBJETOS ............................................................................................ 60

CAPÍTULO 3: MULTI-START............................................................................................. 68 3.1 DESCRIPCIÓN DEL PROGRAMA ..................................................................................... 69 3.2 LISTADO DE OBJETOS................................................................................................... 70

1

RESUMEN Este anexo incluye el código fuente en Java de las aplicaciones informáticas implementadas para el algoritmo de hormigas sin mejora, el algoritmo de hormigas con mejora y el multi-start, así como la descripción funcional de los objetos que las forman.

2

CAPÍTULO 1: ALGORITMO DE HORMIGAS

3

1.1 DESCRIPCIÓN DEL PROGRAMA

El programa está formado por 20 objetos con la siguientes características:

• Azar: crea una semilla para la extracción de números aleatorios.

• CotaSalbpE: cálculo de cotas para el SALBP-E.

• CotasTC: calcula la cota máxima de tiempo de ciclo y la mínima.

• Cronometro: contador de tiempo de ejecución.

• Datos: es el encargado de leer toda la información inicial exterior al programa, así como de crear la lista de sucesores y precedesores inmediatos.

• Evaluacion: dada una secuencia de tareas y un tiempo de ciclo máximo y mínimo, calcula la mejor combinación de tiempo de ciclo y número de estaciones para la secuencia.

• Hormiga: es el encargado de crear una secuencia de tareas. Instancia al objeto Indices y recoge su información.

• Indices: elabora los índices de decisión dada una lista de tareas candidatas y los devuelve para ser utilizados por el objeto Hormiga.

• Listas: contiene las listas de sucesores y predecesores inmediatos, así como la lista de candidatas y de predecesores inmediatos asignado. Actualiza las dos últimas listas cada vez que se asigna una tarea a la secuencia.

• MatrizPesos: crea la matriz de pesos para cada tarea según los 14 criterios heurísticos. Instancia al objeto CotasTC para calcular una primera cota de tiempo de ciclo máximo, necesaria para algunos criterios heurísticos.

• MejorSolucion: contiene la mejor solución global hallada.

• NextTarea: dado un criterio heurístico y una lista de candidatas, elige la siguiente tarea.

• NextTareaInicial: extensión de NextTarea utilizado por la clase SolucionInicial

• Opciones: lee el archivo con opciones y parámetros.

• Principal: clase principal (main). Inicializa los parámetros y crea las subcolonias.

• Rastros: contiene la matriz de rastros, así como los métodos para su inicialización. Además, crea copias de la matriz, controla la desviación de la solución y restaura la matriz de rastros con la copia creada.

• Ristra: contiene la secuencia de tareas en curso. Dada una nueva tarea, actualiza la secuencia.

4

• Salida: métodos para crear los ficheros de salida.

• SolucionInicial: crea una solución inicial mediante una heurística Greedy usando los 14 criterios heurísticos.

• Subcolonia: instancia el objeto Hormiga, lo inicializa y recoge su información. Con esa información, actualiza la matriz de rastros.

5

1.2 LISTADO DE LOS OBJETOS

1.2.1 Principal

public class Principal { public static void main(String arg[]) { int numSubColonia = 0; Subcolonia.numSubcolonia = 0; Cronometro cr = new Cronometro(); cr.inicio(); //Puesta a cero del cronómetro Azar.semilla(); //Inicializa la semilla del random Datos datos = new Datos(arg); datos.importaDatos(); OpcionesTabla op = new OpcionesTabla(arg[4], arg[5]); op.lecturaOpciones(); Salida salida = new Salida(arg[6]); salida.cabecera(); MatrizPesos.inicializa(); CotaSalbpE cota = new CotaSalbpE(); MejorSolucion.inicializa(); Subcolonia.maxsubTC = Datos.TiempoTotal; Subcolonia.mejorsubOBJ = 1000000000; SolucionInicial solini = new SolucionInicial("ID"); solini.lanzaSolucion(); salida.OBJInicial = MejorSolucion.OBJ; Rastros rastro = new Rastros(solini.PaqueteOBJ); rastro.inicializaRastros(); System.out.println(); Subcolonia sub; boolean condicionFinal = false; if(Opciones.tipoLimitacion.equals("HORMIGAS")){ cr.fin(); for(int i=1; (i<=Opciones.limitacion) &&

(condicionFinal == false); i++){ //Creación subcolonia if((i%2) != 0) sub = new Subcolonia(Opciones.tamano, "ID", i); else sub = new Subcolonia(Opciones.tamano, "DI", i); //Lanzamiento subcolonia sub.lanzaHormigas(); numSubColonia++; sub.actualizaRastros();

6

//Control de desvición (backtracking) rastro.controlBacktracking(sub.igualado, sub.mejorado, i,

sub.Sentido); System.out.print("Hormiga # "+i+" OBJ=

"+MejorSolucion.OBJ+" Back= "+ Rastros.contback+"\r");

salida.acumulaSalida(sub); //Escritura de la evolución de //la solución

if(MejorSolucion.OBJ == CotaSalbpE.CotaSalbpE) condicionFinal = true; rastro.trasponer(); cr.fin(); } } else if(Opciones.tipoLimitacion.equals("TIEMPO")){ int i=1; cr.fin(); while((cr.tiempo()<=Opciones.limitacion) &&

((condicionFinal == false))){ if((i%2) != 0) sub = new Subcolonia(Opciones.tamano, "ID", i); else sub = new Subcolonia(Opciones.tamano, "DI", i); sub.lanzaHormigas(); numSubColonia++; sub.actualizaRastros(); System.out.print("Hormiga # "+i+"\r"); rastro.controlBacktracking(sub.igualado, sub.mejorado, i,

sub.Sentido); if(MejorSolucion.OBJ == Datos.OBJOptima) condicionFinal = true; rastro.trasponer(); cr.fin(); //Controla el tiempo que ha transcurrido i++; } } System.out.println(); System.out.println(); System.out.println("MEJOR SOLUCION"); System.out.println("OBJ= "+MejorSolucion.OBJ); System.out.println("N = "+MejorSolucion.N); System.out.println("TC = "+MejorSolucion.TC); cr.fin(); System.out.println(); System.out.println("Tiempo de ejecucion: "+cr.tiempo()+" s"); salida.tablaSalida(numSubColonia, cr.tiempo()); salida.rellenaBlancos(numSubColonia); salida.estacionesSalida();

7

salida.escribeSalida(); } }

1.2.2 Listas

public class Listas { int ListaSuc[][]; int ListaPred[]; int ListaPredAsig[]; int Candidatas[]; int limCandidatas = 0; //Marca el final de la lista de candidatas String Sentido; public Listas(String s) { Sentido = s; // Sentido = ID ó DI copiaListas(); inicializaCandidatas(); } //Crea una copia de trabajo para la hormiga de la lista de sucesoras //y precedesoras inmediatas según el sentido de la hormigo public void copiaListas() { if(Sentido.equals("ID")){ ListaSuc = Datos.ListaSucID; ListaPred = Datos.ListaPredID; } else if(Sentido.equals("DI")){ ListaSuc = Datos.ListaSucDI; ListaPred = Datos.ListaPredDI; } ListaPredAsig = new int[Datos.NumTareas+1]; } //Calcula las candidatas por primera vez: //Aquellas tareas que no tienen precedentes public void inicializaCandidatas() { //Se crea la lista de candidatas

Candidatas = new int[Datos.NumTareas+1]; for(int i=1; i<=Datos.NumTareas ; i++){ if(ListaPred[i] == 0){ limCandidatas++; //Aumenta el tamaño de la venta

//de la lista de candidatas Candidatas[limCandidatas] = i; } } }

8

//Actualiza la lista de predecesoras inmediatas y la lista de //candidatas dada la nueva tarea asignada y la posicion que

//ocupa en la lista de candidatas public void actualizaListas(int TareaPos[]) { //Tareas que van a ser nuevas candidatas int nuevasCandidatas[] = new int[ListaSuc[1].length]; int aux=0; int suc=0; int lookTarea; while((suc<=(ListaSuc[1].length-1)) &&

(ListaSuc[TareaPos[0]][suc] != 0)){ lookTarea = ListaSuc[TareaPos[0]][suc] ; ListaPredAsig[lookTarea]++; //Aumenta en 1 el número de

//predecesoras asigna de la tareas //sucesoras a la asignada

if(ListaPred[lookTarea] == ListaPredAsig[lookTarea]){ nuevasCandidatas[aux] = lookTarea; aux++; } suc++; }

actualizaCandidata(nuevasCandidatas,ListaSuc[1].length, TareaPos[1]);

} public void actualizaCandidata(int nuevas[],int longitud, int posicion) { if(nuevas[0]==0){ //No hay ninguna candidata nueva for(int i=posicion; i<=(limCandidatas-1); i++) Candidatas[i] = Candidatas[i+1]; limCandidatas--; } else { Candidatas[posicion] = nuevas[0]; if(longitud > 1){ int i=1; while((i<=(longitud-1)) && (nuevas[i] !=0)){ Candidatas[limCandidatas+1] = nuevas[i]; limCandidatas++; i++; }; } } } }

1.2.3 Ristra

public class Ristra {

9

int RistraT[]; //Secuencias de tareas int contTarea = 1; public int ultimaH; //Última heurística asignada public int ultimaT; //Última tarea asignada public Evaluacion eval; public NextTarea next; public Ristra(String sentido) { RistraT = new int[Datos.NumTareas+1]; ultimaT = 0; next = new NextTarea(sentido); ultimaH = 0; } public void actualizaRistraT(int tarea) { RistraT[contTarea] = tarea; ultimaT = tarea; contTarea++; } public int[] getRistraT() { return RistraT; } public void evaluacionRistra(){ eval = new Evaluacion(RistraT); eval.evalua(); } }

1.2.4 NextTarea

public class NextTarea { Listas lista; int heuristica; int ultimaT; //Última tarea asignada // en este vector se guardaran la tarea // y la posicion que que devolvera la funcion int tarea[]= new int[2]; String sentido; //Al constructor hay que pasarle la heuristica para que decida //la siguiente tarea en funcion de dicha heuristica y un String que //solo puede ser ID o DI dependiendo si se quiere un lista //preparada para rellenar una ristra con el problema directo (ID) //o inverso (DI)

10

public NextTarea(String r) { sentido = r; lista = new Listas(sentido); } //Método que devuelve la siguiente tarea y su posición dentro de la //lista de candidatas public int[] getTarea(int h, int u) { heuristica=h; ultimaT=u; if(lista.limCandidatas >=1){ if(sentido.equals("ID")) return eligeTareaID(); else return eligeTareaDI(); } else { tarea[0] = -1; //Condición de final tarea[1] = -1; return tarea; } } public int[] eligeTareaID() { int empates; //Cada fila de la matriz TareaPosAux [k][j] contiene en la //posicion k una para el desempate y en j su posicion //se utiliza la posicion "0" del vector int TareaPosAux[][]= new int[lista.limCandidatas][2]; //Se inicializa el peso maximo y su posicion //(dentro de la lista de candidatas) con la primera candidata TareaPosAux[0][0]=lista.Candidatas[1]; TareaPosAux[0][1]=1; //En la lista de candidatas no se utiliza la //primera posicion se calcula el peso de la tarea

//candidata con mayor peso empates=0; for (int i=1; i <= lista.limCandidatas-1; i++ ){ int a=MatrizPesos.MatrizID[heuristica][lista.Candidatas[i+1]]; int c=MatrizPesos.MatrizID[heuristica][2]; int b=MatrizPesos.MatrizID[heuristica][TareaPosAux[0][0]]; if (MatrizPesos.MatrizID[heuristica][lista.Candidatas[i+1]] == MatrizPesos.MatrizID[heuristica][TareaPosAux[0][0]]){ empates++; TareaPosAux[empates][0]=lista.Candidatas[i+1]; TareaPosAux[empates][1]=i+1; } else if(MatrizPesos.MatrizID[heuristica]

[lista.Candidatas[i+1]]> MatrizPesos.MatrizID[heuristica][TareaPosAux[0][0]]){ empates=0;

11

TareaPosAux[empates][0]=lista.Candidatas[i+1]; TareaPosAux[empates][1]=i+1; } } //Si el numero de empates es mayor que 0 //se debe desempatar if (empates>0) { //Al método se le pasa la lista de empates //y el numero de empates y devuelve la tarea //despues del desempate tarea = desempate (TareaPosAux,empates); } else if (empates==0){ tarea[0] = TareaPosAux[0][0]; tarea[1] = TareaPosAux[0][1]; } return tarea; } public int[] eligeTareaDI() { int empates; //Cada fila de la matriz TareaPosAux [k][j] contiene

//en la posicion k una para el desempate y en j su posicion //se utiliza la posicion "0" del vector int TareaPosAux[][]= new int[lista.limCandidatas][2]; //Se inicializa el peso maximo y su posicion //(dentro de la lista de candidatas) con la primera candidata TareaPosAux[0][0]=lista.Candidatas[1]; TareaPosAux[0][1]=1; //En la lista de candidatas no se utiliza la //primera posicion se calcula el peso de la tarea

//candidata con mayor peso empates=0; for (int i=1; i <= lista.limCandidatas-1; i++ ){ if (MatrizPesos.MatrizDI[heuristica][lista.Candidatas[i+1]] == MatrizPesos.MatrizDI[heuristica][TareaPosAux[0][0]]){ empates++; TareaPosAux[empates][0]=lista.Candidatas[i+1]; TareaPosAux[empates][1]=i+1; } else if (MatrizPesos.MatrizDI[heuristica]

[lista.Candidatas[i+1]]> MatrizPesos.MatrizDI[heuristica][TareaPosAux[0][0]]){ empates=0; TareaPosAux[empates][0]=lista.Candidatas[i+1]; TareaPosAux[empates][1]=i+1; } } //Si el numero de empates es mayor que 0 //se debe desempatar if (empates>0) {

12

//Al método se le pasa la lista de empates y el numero //de empates y devuelve la tarea despues del desempate tarea = desempate (TareaPosAux,empates); } else if (empates==0){ tarea[0] = TareaPosAux[0][0]; tarea[1] = TareaPosAux[0][1]; } return tarea; } public int[] desempate (int TareaPosAux[][],int empates) { int empatesRastro; int tareaPos[] = new int[2]; //Vector donde se guardan las tareas con el rastro maximo,

//si existen mas de 1, se escogerá una al azar double sameRastro[][] = new double [empates+1][3]; sameRastro[0][0] = TareaPosAux[0][0]; sameRastro[0][1] = TareaPosAux[0][1]; sameRastro[0][2] = Rastros.Tareas[ultimaT][TareaPosAux[0][0]]; empatesRastro=0; for (int i=0; i <= empates-1; i++){ if (Rastros.Tareas[ultimaT][TareaPosAux[i+1][0]] == Rastros.Tareas[ultimaT][(int)(sameRastro[0][0])]){ empatesRastro++; sameRastro[empatesRastro][0] = TareaPosAux[i+1][0]; sameRastro[empatesRastro][1] = TareaPosAux[i+1][1]; sameRastro[empatesRastro][2] = Rastros.Tareas[ultimaT]

[TareaPosAux[i+1][0]]; } else if (Rastros.Tareas[ultimaT][TareaPosAux[i+1][0]]> Rastros.Tareas[ultimaT][(int)(sameRastro[0][0])]){ empatesRastro=0; sameRastro[empatesRastro][0]=TareaPosAux[i+1][0]; sameRastro[empatesRastro][1]=TareaPosAux[i+1][1]; sameRastro[empatesRastro][2]=

Rastros.Tareas[ultimaT][TareaPosAux[i+1][0]]; } } if (empatesRastro>0) { int azar; azar = Azar.nextInt(0,empatesRastro); tarea[0] = (int) (sameRastro[azar][0]); tarea[1] = (int) (sameRastro[azar][1]); } else if (empatesRastro==0){ tarea[0] = (int) (sameRastro[0][0]); tarea[1] = (int) (sameRastro[0][1]); }else if (empatesRastro < 0) System.out.println("error en Next Tarea Desempate:

13

empates rastro menor que 0"); return tarea; } }

1.2.5 SoluciónInicial

public class SolucionInicial { String sentido; int tareapos[]; Ristra ristra; NextTareaInicial next; int PaqueteRistras[][]; int PaqueteOBJ[]; int numAnt; public SolucionInicial(String sentido) { this.sentido = sentido; PaqueteOBJ = new int[15]; PaqueteRistras = new int[15][Datos.NumTareas+1]; numAnt = 1; } public void lanzaSolucion() { for(int h=1; h<=14; h++){ creaSolucion(h); recogeInformacion(); comparaInformacion(); numAnt++; } System.out.println(); System.out.println("MEJOR SOLUCION INICIAL"); System.out.println("OBJ= "+MejorSolucion.OBJ); System.out.println("N = "+MejorSolucion.N); System.out.println("TC = "+MejorSolucion.TC); } public void creaSolucion(int h) { tareapos = new int[2]; ristra = new Ristra(sentido); next = new NextTareaInicial(sentido); for(int i=1; i<=Datos.NumTareas; i++){ tareapos = next.getTarea(h, ristra.ultimaT); ristra.actualizaRistraT(tareapos[0]); next.lista.actualizaListas(tareapos); }

14

ristra.evaluacionRistra(); } public void recogeInformacion() { for(int i=1; i<=Datos.NumTareas; i++) PaqueteRistras[numAnt][i] = ristra.RistraT[i]; PaqueteOBJ[numAnt] = ristra.eval.getObj(); } public void comparaInformacion() { if(PaqueteOBJ[numAnt] < MejorSolucion.OBJ){ MejorSolucion.OBJ = PaqueteOBJ[numAnt]; MejorSolucion.N = ristra.eval.getNumEst(); MejorSolucion.TC = ristra.eval.getTC(); for(int i=1; i<=Datos.NumTareas; i++) MejorSolucion.Ristra[i] = PaqueteRistras[numAnt][i]; MejorSolucion.sentidoHormiga = "ID"; } } }

1.2.6 NextTareaInicial

public class NextTareaInicial extends NextTarea { public NextTareaInicial(String r) { super(r); lista = new Listas(sentido); } public int[] desempate (int TareaPosAux[][],int empates) { int i=1; int tareaPos[] = new int[2]; tareaPos[0]=TareaPosAux[0][0]; tareaPos[1]=TareaPosAux[0][1]; for (i=1; i <= empates ; i++){ if(sentido.equals("ID")){ if (TareaPosAux[i][0] < tareaPos[0]){ tareaPos[0] = TareaPosAux[i][0]; tareaPos[1] = TareaPosAux[i][1]; } } else { if (TareaPosAux[i][0] > tareaPos[0]){ tareaPos[0] = TareaPosAux[i][0]; tareaPos[1] = TareaPosAux[i][1]; } } }

15

return tareaPos; } }

1.2.7 Indices

import java.math.*; public class Indices { int HeuIntrinseca; //Heurística intrínseca a la hormiga double VectorIndices[]; //Índices de decisión int t[][]; //Tarea asociada a la heurística elegida //y su posición en la lista de candidatas Ristra ristra; String tipo; int limCandidatas; public Indices(int i) { HeuIntrinseca = i; } public int[] eligeTarea(Ristra r, String t) { ristra = r; tipo = t; limCandidatas = ristra.next.lista.limCandidatas; VectorIndices = new double[limCandidatas+1]; VectorIndices = calculoIndices(); if(tipo.equals("ALEA")) return sorteo(); else return maximo(); } //Calcula los índices de decisión public double[] calculoIndices() { double vectorAux[] = new double[limCandidatas+1]; double sumaDenominador = 0; int ph[] = new int[limCandidatas+1]; //Peso de la tarea con la

//heurística intrínseca int sumaph = 0; //Denominador para ponderar los ph double sumaRastro = (double) (0.0); //Denominador para ponderar

//los rastros for(int i=1; i<=limCandidatas; i++){ int taux; //Tarea de la posicion i de la lista de candidatas taux = ristra.next.lista.Candidatas[i]; ph[i] = Hormiga.Pesos[HeuIntrinseca][taux]; sumaph += ph[i]; sumaRastro += Rastros.Tareas[ristra.ultimaT][taux]; }

16

//Índices sin acumulación if(Opciones.ponderacionIndices.equals("SI")){ for(int i=1; i<=limCandidatas; i++){ int taux; //Tarea de la posicion i de

//la lista de candidatas taux = ristra.next.lista.Candidatas[i]; vectorAux[i] = (Math.pow(100*

(Rastros.Tareas[ristra.ultimaT][taux])/ sumaRastro, Opciones.alfa)) *

Math.pow(100*((double)(ph[i])/ (double)(sumaph)), Opciones.beta));

sumaDenominador += vectorAux[i]; } } else if(Opciones.ponderacionIndices.equals("NO")){ for(int i=1; i<=limCandidatas; i++){ int taux; taux = ristra.next.lista.Candidatas[i]; vectorAux[i] = (Math.pow(

(Rastros.Tareas[ristra.ultimaT][taux]), Opciones.alfa)) * (Math.pow((double)(ph[i]), Opciones.beta)); sumaDenominador += vectorAux[i]; } } else System.out.println("ERROR: Elegir si hay o no índices de

ponderación"); if(tipo.equals("ALEA")){ VectorIndices[0] = 0; for(int i=1; i<=limCandidatas; i++) VectorIndices[i] = VectorIndices[i-1] +

vectorAux[i]/sumaDenominador; } else { for(int i=1; i<=limCandidatas; i++) VectorIndices[i] = vectorAux[i]; } return VectorIndices; } public int[] sorteo(){ int cand = limCandidatas; //Nº candidata escogida en el sorteo //cand=limCanditas al inicio para

//asegurar la candidata //en caso de que rand sea igual a 1 double rand = Azar.aleatorio.nextDouble(); for(int i=1; i<=limCandidatas; i++){ if((rand >= VectorIndices[i-1]) && (rand < VectorIndices[i])){ cand = i; i = limCandidatas+1; //Marca para salir del bucle } }

17

int tareapos[] = new int[2]; tareapos[0] = ristra.next.lista.Candidatas[cand]; tareapos[1] = cand; return tareapos; } public int[] maximo(){ int cand = 1; //Tarea escogida por ser la de mayor índice for(int i=2; i<=limCandidatas; i++){ if(VectorIndices[i]>VectorIndices[cand]) cand = i; } int tareapos[] = new int[2]; tareapos[0] = ristra.next.lista.Candidatas[cand]; tareapos[1] = cand; return tareapos; } }

1.2.8 Hormiga

import java.math.*; public class Hormiga { Ristra ristra; Indices indices; int heuIntrinseca; String sentido; String tipo; static int Pesos[][]; //Matriz de pesos estandarizada public Hormiga(int h, String s, String t) { heuIntrinseca = h; //Heurística intrínseca sentido = s; //Dirección: ID ó DI tipo = t; //Aleatoria o pseudo-aleatoria ristra = new Ristra(sentido); indices = new Indices(heuIntrinseca); if(sentido.equals("ID")) Pesos = MatrizPesos.MatrizID; else Pesos = MatrizPesos.MatrizDI; } public void construirSolucion() {

18

//Opción según hormigas aleatorias o pseudo-aleatorias if(tipo.equals("ALEA")) aleatorio(1, Datos.NumTareas); else if(tipo.equals("PSEUDO")) pseudoAleatorio(); ristra.evaluacionRistra(); } public void aleatorio(int inicio, int fin) { int tareapos[]; //Tarea elegida for(int i=inicio; i<=fin; i++){ tareapos = indices.eligeTarea(ristra, "ALEA"); //Se añade la tarea a la secuencia de tareas ristra.actualizaRistraT(tareapos[0]); //Se actualiza la lista de candidatas ristra.next.lista.actualizaListas(tareapos); } } public void pseudoAleatorio() { int tareapos[] = new int[2]; //Tarea elegida double rand; //Índice para el sorteo pesudo-aleatorio for(int cont=1; cont<=Datos.NumTareas; cont++){ rand = Math.random(); if(rand>Opciones.indicePseudo) //Elige ser aleatorio aleatorio(cont, cont); else { //Elige ser pseudo-aleatorio tareapos = indices.eligeTarea(ristra, "PSEUDO"); ristra.actualizaRistraT(tareapos[0]); ristra.next.lista.actualizaListas(tareapos); } } } }

1.2.9 Evaluacion

import java.math.*; public class Evaluacion { private int Ristra[]; private int Obj, TC, NumEst; String mejorSentido;

19

public Evaluacion(int ris[]) { Ristra = ris; } public void evalua() { mejorSentido = "ID"; evaluaID(); evaluaDI(); MejorSolucion.sentidoEval = mejorSentido; } public void evaluaID() { int TC2 = CotasTC.CotaMinTC; Obj = 1000000000; int tacum, tasig, TCajust2, n2, TCnext; int i, r; int marca, cota2; int obj2 = Obj+1; //Se pone porque hay que inicilizarla!!! do{ //loop de tiempos de ciclo tacum = 0; tasig = 0; TCajust2 = 0; n2 = 1; r = 1; marca = 0; cota2 = 1; TCnext = 1000000000; Salida.numSol++; //Contador del número de soluciones evaluadas do{ //loop de r i = Ristra[r]; tacum += Datos.Tiempos[i]; if(tacum > TC2){ if((tacum-Datos.Tiempos[i]) > TCajust2) TCajust2 = tacum-Datos.Tiempos[i]; if(tacum < TCnext) TCnext = tacum; tasig = tasig + tacum - Datos.Tiempos[i]; tacum = Datos.Tiempos[i]; n2 += 1; if((n2-1+

(int)Math.floor((double)(Datos.TiempoTotal- tasig)/TC2))*TCajust2 >=

Subcolonia.mejorsubOBJ) cota2 = 0; } if(r==Datos.NumTareas) marca = 1; r++; } while((r<=Datos.NumTareas) &&

(n2*TCajust2<Subcolonia.mejorsubOBJ) && (cota2>0) && (n2<=Datos.NumEstMax));

20

if(tacum>TCajust2) {TCajust2 = tacum;} if(TC2 == Datos.TiempoTotal) {TCajust2 = TC2;} if((marca==1) && n2<=Datos.NumEstMax) {obj2 = TCajust2*n2;} else if((marca==0) || n2>Datos.NumEstMax) {obj2 = Obj +1;} if(n2<=Datos.NumEstMax){ if(n2 > Datos.NumEstMin){ if((obj2 <= Obj) && (marca==1)){ Obj = obj2; TC = TCajust2; NumEst = n2; Subcolonia.mejorsubOBJ = Obj; } TC2 = TCnext; } else if(n2 == Datos.NumEstMin){ if(marca == 1){ if(TCajust2<CotasTC.CotaMaxTC){ CotasTC.CotaMaxTC = TCajust2; MatrizPesos.actualizaPesos(); } if(TCajust2<Subcolonia.maxsubTC){ Subcolonia.maxsubTC = TCajust2; } if(obj2 <= Obj){ Obj = obj2; TC = TCajust2; NumEst = n2; Subcolonia.mejorsubOBJ = Obj; } TC2 = Datos.TiempoTotal+1; } else if(marca == 0){ if((Datos.TiempoTotal-tasig)<=TC2){ if((Datos.TiempoTotal-tasig)>TCajust2) TCajust2 = Datos.TiempoTotal-tasig; obj2 = n2*TCajust2; if(obj2 <= Obj){ Obj = obj2; TC = TCajust2; NumEst = n2; Subcolonia.mejorsubOBJ = Obj; } if(TCajust2<CotasTC.CotaMaxTC){ CotasTC.CotaMaxTC = TCajust2; MatrizPesos.actualizaPesos(); } if(TCajust2<Subcolonia.maxsubTC){ Subcolonia.maxsubTC = TCajust2; } TC2 = Datos.TiempoTotal+1; } else if((Datos.TiempoTotal-tasig)>TC2) TC2 = TCnext; } } else if(n2<Datos.NumEstMin){ if(marca == 1) TC2 = Datos.TiempoTotal+1; else if(marca == 0){

21

if((n2-1+(int)Math.floor( (double)(Datos.TiempoTotal-tasig)/TC2))

> Datos.NumEstMin) TC2 = TCnext; else if((n2-1+(int)Math.floor(

(double)(Datos.TiempoTotal-tasig)/TC2)) <= Datos.NumEstMin) TC2 = Datos.TiempoTotal+1; } } } else TC2 = TCnext; } while(TC2 <= Subcolonia.maxsubTC); } public void evaluaDI() { int TC2 = CotasTC.CotaMinTC; int tacum, tasig, TCajust2, n2, TCnext; int i, r; int marca, cota2; int obj2 = Obj+1; //Se pone porque hay que inicilizarla!!! do{ //loop de tiempos de ciclo tacum = 0; tasig = 0; TCajust2 = 0; n2 = 1; r = 1; marca = 0; cota2 = 1; TCnext = 1000000000; Salida.numSol++; //Contador del número de soluciones evaluadas do{ //loop de r i = Ristra[r]; tacum += Datos.Tiempos[i]; if(tacum > TC2){ if((tacum-Datos.Tiempos[i]) > TCajust2) TCajust2 = tacum-Datos.Tiempos[i]; if(tacum < TCnext) TCnext = tacum; tasig = tasig + tacum - Datos.Tiempos[i]; tacum = Datos.Tiempos[i]; n2 += 1; if((n2-1+

(int)Math.floor((double)(Datos.TiempoTotal- tasig)/TC2))*TCajust2 >=

Subcolonia.mejorsubOBJ) cota2 = 0; } if(r==Datos.NumTareas) marca = 1; r++; } while((r<=Datos.NumTareas) &&

(n2*TCajust2<Subcolonia.mejorsubOBJ) && (cota2>0) && (n2<=Datos.NumEstMax));

22

if(tacum>TCajust2) {TCajust2 = tacum;} if(TC2 == Datos.TiempoTotal) {TCajust2 = TC2;} if((marca==1) && n2<=Datos.NumEstMax) {obj2 = TCajust2*n2;} else if((marca==0) || n2>Datos.NumEstMax) {obj2 = Obj +1;} if(n2<=Datos.NumEstMax){ if(n2 > Datos.NumEstMin){ if((obj2 <= Obj) && (marca==1)){ Obj = obj2; TC = TCajust2; NumEst = n2; mejorSentido = "DI"; Subcolonia.mejorsubOBJ = Obj; } TC2 = TCnext; } else if(n2 == Datos.NumEstMin){ if(marca == 1){ if(TCajust2<CotasTC.CotaMaxTC){ CotasTC.CotaMaxTC = TCajust2; MatrizPesos.actualizaPesos(); } if(TCajust2<Subcolonia.maxsubTC){ Subcolonia.maxsubTC = TCajust2; } if(obj2 <= Obj){ Obj = obj2; TC = TCajust2; NumEst = n2; mejorSentido = "DI"; Subcolonia.mejorsubOBJ = Obj; } TC2 = Datos.TiempoTotal+1; } else if(marca == 0){ if((Datos.TiempoTotal-tasig)<=TC2){ if((Datos.TiempoTotal-tasig)>TCajust2) TCajust2 = Datos.TiempoTotal-tasig; obj2 = n2*TCajust2; if(obj2 <= Obj){ Obj = obj2; TC = TCajust2; NumEst = n2; mejorSentido = "DI"; Subcolonia.mejorsubOBJ = Obj; } if(TCajust2<CotasTC.CotaMaxTC){ CotasTC.CotaMaxTC = TCajust2; MatrizPesos.actualizaPesos(); } if(TCajust2<Subcolonia.maxsubTC){ Subcolonia.maxsubTC = TCajust2; } TC2 = Datos.TiempoTotal+1; } else if((Datos.TiempoTotal-tasig)>TC2) TC2 = TCnext; } } else if(n2<Datos.NumEstMin){

23

if(marca == 1) TC2 = Datos.TiempoTotal+1; else if(marca == 0){ if((n2-1+(int)Math.floor(

(double)(Datos.TiempoTotal-tasig)/TC2)) > Datos.NumEstMin)

TC2 = TCnext; else if((n2-1+(int)Math.floor(

(double)(Datos.TiempoTotal-tasig)/TC2)) <= Datos.NumEstMin) TC2 = Datos.TiempoTotal+1; } } } else TC2 = TCnext; } while(TC2 <= Subcolonia.maxsubTC); } public int getObj(){ return Obj; } public int getTC(){ return TC; } public int getNumEst(){ return NumEst; } }

1.2.10 Rastros

import java.math.*; public class Rastros { static double[][] Tareas; int[] solini; int contBacktracking, auxBacktracking; double[][] copiaTareas; static int contback; public Rastros(int[] s) { solini = s; Tareas = new double[Datos.NumTareas+1][Datos.NumTareas+1]; copiaTareas = new double[Datos.NumTareas+1][Datos.NumTareas+1]; contBacktracking = 0; auxBacktracking = 0; contback = 0; } public void inicializaRastros()

24

{ if(Opciones.tipoRastro.equals("CONSTANTE")) constante(); else if(Opciones.tipoRastro.equals("ALEATORIO")) aleatorio(); } public void constante() { for(int i=0; i<=Datos.getNumTareas(); i++){ for(int j=0; j<=Datos.getNumTareas(); j++){ Tareas[i][j] = Opciones.rastroInicial; } } } public void aleatorio() { for(int i=0; i<=Datos.getNumTareas(); i++){ for(int j=0; j<=Datos.getNumTareas(); j++){ Tareas[i][j] = Azar.aleatorio.nextInt(); } } } public void trasponer() { double aux; for(int i=0; i<=Datos.NumTareas; i++){ for(int j=i+1; j<=Datos.NumTareas; j++){ aux = Tareas[i][j]; Tareas[i][j] = Tareas[j][i]; Tareas[j][i] = aux; } } } //Hace una copia de la Matriz de Rastros //para poder restaurarla en caso de backtracking public void copiaRastro(String sentido) { //La matriz de copia siempre se guarda en sentido ID if(sentido.equals("ID")){ for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++) copiaTareas[i][j] = Tareas[i][j]; } } else { for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++)

25

copiaTareas[i][j] = Tareas[j][i]; } } } //Sustituye la matriz actual por la //copia guardada por copiaRastro() public void restauraRastro(String sentido) { //La matriz de copia siempre se guarda en sentido ID if(sentido.equals("ID")){ for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++) Tareas[i][j] = copiaTareas[i][j]; } } else { for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++) Tareas[i][j] = copiaTareas[j][i]; } } } //Controla la desviación de las soluciones //y decide si es necesario un backtracking public void controlBacktracking(boolean igualado, boolean mejorado,

int subcolonia, String sentido) { if(igualado == true) contBacktracking++; if(mejorado == true){ auxBacktracking = subcolonia; contBacktracking = 1; copiaRastro(sentido); } if(subcolonia > (auxBacktracking+100)){ if(contBacktracking < 40){ restauraRastro(sentido); contback++; } auxBacktracking = subcolonia; contBacktracking = 0; } } }

1.2.11 Subcolonia

public class Subcolonia { int tamano; //1 ó 14 String Sentido;

26

Hormiga ant; int numAnt = 0; double b; boolean marcaMejor = false; //true si la mejor hormiga mejora

//o iguala la OBJ global boolean marcaMejorSolo = false; //true si la mejor hormiga

//mejora la OBJ global boolean mejorado, igualado; //Parámetros para el control

//de backtracking static int mejorsubOBJ; static int maxsubTC; static int numSubcolonia; MejoraLocal mejora; //Atributos para la recolección de información int PaqueteRistras[][]; int PaqueteOBJ[]; int PaqueteN[]; int PaqueteTC[]; int numSub; public Subcolonia(int t, String s, int n) { tamano = t; Sentido = s; PaqueteOBJ = new int[14]; PaqueteRistras = new int[14][Datos.NumTareas+1]; PaqueteN = new int[14]; PaqueteTC = new int[14]; MatrizPesos.actualizaPesoAzar(Sentido); mejorsubOBJ = 2000000000; maxsubTC = Datos.TiempoTotal; rastretes = Rastros.Tareas; numSub = n; igualado = false; mejorado = false; } public void lanzaHormigas() { for(int i=1; i<=14; i++){ ant = new Hormiga(i, Sentido, Opciones.tipoHormiga); ant.construirSolucion(); recogeInformacion(); comparaInformacion(); numAnt++; } numSubcolonia++; }

27

public void recogeInformacion() { for(int i=1; i<=Datos.NumTareas; i++) PaqueteRistras[numAnt][i] = ant.ristra.RistraT[i]; PaqueteOBJ[numAnt] = ant.ristra.eval.getObj(); PaqueteN[numAnt] = ant.ristra.eval.getNumEst(); PaqueteTC[numAnt] = ant.ristra.eval.getTC(); } public void comparaInformacion() { if(PaqueteOBJ[numAnt] < MejorSolucion.OBJ){ MejorSolucion.OBJ = PaqueteOBJ[numAnt]; MejorSolucion.N = PaqueteN[numAnt]; MejorSolucion.TC = PaqueteTC[numAnt]; for(int i=1; i<=Datos.NumTareas; i++) MejorSolucion.Ristra[i] = PaqueteRistras[numAnt][i]; MejorSolucion.sentidoHormiga = Sentido; MejorSolucion.sentidoEval = ant.ristra.eval.mejorSentido; marcaMejorSolo = true; mejorado = true; } if(PaqueteOBJ[numAnt] <= MejorSolucion.OBJ){ marcaMejor = true; igualado = true; } } public void actualizaRastros() { evaporaRastros(); actualizaTareas(); } public void actualizaTareas() { double unidadRastro[] = new double[15]; double sumaOBJ = 0; int tareaA, tareaB; if(tamano == 14){ //Dejan rastro todas las hormigas for(int i=0; i<=13; i++){ b = 100.0*(((double)(PaqueteOBJ[i])-

(double)(Datos.TiempoTotal))/ ((double)(Datos.TiempoTotal))); unidadRastro[i] = 1/(Math.pow(b, 1.0)); } for(int contAnt = 0; contAnt<=13; contAnt++){ tareaA = 0;

28

for(int r=1; r<=Datos.NumTareas; r++){ tareaB = PaqueteRistras[contAnt][r]; Rastros.Tareas[tareaA][tareaB] +=

unidadRastro[contAnt]; tareaA = tareaB; } } } //Sólo dejan rastro las mejores hormigas int minOBJ[] = new int[14]; //Contiene las hormigas con mejor OBJ int limAnt = 0; minOBJ[0] = 0; for(int contAnt=1; contAnt<=13; contAnt++){ if(PaqueteOBJ[contAnt]<PaqueteOBJ[minOBJ[0]]){ minOBJ[0] = contAnt; limAnt = 0; } else if(PaqueteOBJ[contAnt]==PaqueteOBJ[minOBJ[0]]){ minOBJ[limAnt+1] = contAnt; limAnt++; } } if(marcaMejor == true){ //La mejor hormiga mejora o

//iguala la OBJ global for(int i=0; i<=limAnt; i++){ tareaA = 0; for(int r=1; r<=Datos.NumTareas; r++){ tareaB = PaqueteRistras[minOBJ[i]][r]; double maxRastro = 0.0; //Se busca el máximo rastro

for(int j=0; j<=Datos.NumTareas; j++){ if(Rastros.Tareas[tareaA][j] > maxRastro) maxRastro = Rastros.Tareas[tareaA][j]; } //Rastro extra if(marcaMejorSolo == true){ for(int j=0; j<=Datos.NumTareas; j++)

Rastros.Tareas[tareaA][j] *= (1-Opciones.evaporacionExtra);

maxRastro *= Opciones.rastroExtra; }

//Iguala el máximo rastro Rastros.Tareas[tareaA][tareaB] = maxRastro; tareaA = tareaB; } if(marcaMejorSolo == true){ //Última tarea de la secuencia double maxRastro = 0.0; for(int j=0; j<=Datos.NumTareas; j++){

//Se busca el máximo rastro if(Rastros.Tareas[tareaA][j] > maxRastro) maxRastro = Rastros.Tareas[tareaA][j]; } for(int pos=0; pos<=Datos.NumTareas; pos++)

//Evaporación extra de la fila de la

29

//última tarea de la ristra Rastros.Tareas[tareaA][pos] *=

(1-Opciones.evaporacionExtra); maxRastro *= Opciones.rastroExtra; Rastros.Tareas[tareaA][0] = maxRastro; marcaMejorSolo = false; //Ya no entra más, sólo evapora //la primera hormiga } } } for(int i=0; i<=limAnt; i++){ b = 100.0*(((double)(PaqueteOBJ[minOBJ[i]])-

((double)(CotaSalbpE.CotaSalbpE)))/ ((double)(CotaSalbpE.CotaSalbpE))); double unidad = 1/(Math.pow(b, 2.0)); tareaA = 0; for(int r=1; r<=Datos.NumTareas; r++){ tareaB = PaqueteRistras[minOBJ[i]][r]; Rastros.Tareas[tareaA][tareaB] += unidad; tareaA = tareaB; } Rastros.Tareas[tareaA][0] += unidad;

//Rastro entre la última tarea de la ristra //y la tarea 0 en sentido contrario } } public void evaporaRastros() { for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++) Rastros.Tareas[i][j] = Rastros.Tareas[i][j]*

(1.0-Opciones.evaporacion); } } }

1.2.12 Opciones

import java.io.*; import java.util.*; public class Opciones { private String fichero; static double alfa; static double beta; static double evaporacion ;

30

static double evaporacionExtra; static double rastroExtra; static int tamano; static String tipoHormiga; static double indicePseudo; static String sentido; static double rastroInicial; static double coefDifusion; static String tipoRastro; static String tipoLimitacion; static int limitacion; static String ponderacionIndices; public Opciones(String f) { fichero = f; } public void lecturaOpciones() { try{ String descripcion; BufferedReader inbr = new BufferedReader(

new FileReader(fichero)); String inString = inbr.readLine(); StringTokenizer st = new StringTokenizer(inString); descripcion = st.nextToken(); while(!descripcion.equals("fin")){ if(descripcion.equals("alfa")) alfa = Double.valueOf(

st.nextToken().trim()).doubleValue(); else if(descripcion.equals("beta")) beta = Double.valueOf(

st.nextToken().trim()).doubleValue(); else if(descripcion.equals("evaporacion")) evaporacion = Double.valueOf(

st.nextToken().trim()).doubleValue(); else if(descripcion.equals("evaporacionExtra")) evaporacionExtra = Double.valueOf(

st.nextToken().trim()).doubleValue(); else if(descripcion.equals("rastroExtra")) rastroExtra = Double.valueOf(

st.nextToken().trim()).doubleValue(); else if(descripcion.equals("tipoHormiga")){ tipoHormiga = st.nextToken(); if(tipoHormiga.equals("PSEUDO")) indicePseudo = Double.valueOf(

st.nextToken().trim()).doubleValue(); } else if(descripcion.equals("sentido")) sentido = st.nextToken(); else if(descripcion.equals("tamano")) tamano = Integer.valueOf(

st.nextToken().trim()).intValue();

31

else if(descripcion.equals("rastroInicial")){ tipoRastro = st.nextToken(); if(tipoRastro.equals("CONSTANTE")) rastroInicial = Double.valueOf(

st.nextToken().trim()).doubleValue(); if(tipoRastro.equals("DIFUSION")) coefDifusion = Double.valueOf(

st.nextToken().trim()).doubleValue(); } else if(descripcion.equals("limitacion")){ tipoLimitacion = st.nextToken(); limitacion = Integer.valueOf(

st.nextToken().trim()).intValue(); } else if(descripcion.equals("ponderacionIndices")) ponderacionIndices = st.nextToken(); inString = inbr.readLine(); st = new StringTokenizer(inString); descripcion = st.nextToken(); } } catch(EOFException e) { System.out.println("End of stream encountered"); } catch(FileNotFoundException e) { System.out.println("File Not Found:" + fichero); } catch(IOException e){ System.out.println("IO Exception"); } } }

1.2.13 Datos

import java.io.*; import java.util.*; public class Datos { static int NumTareas; static int NumEstMin, NumEstMax; static int Tiempos[]; static int MatrizSucI[][]; static int MatrizSuc[][]; static int MatrizPre[][]; static int ListaSucID[][]; static int ListaSucDI[][]; static int ListaPredID[]; static int ListaPredDI[]; static int TiempoTotal; static int TiempoMax; static int OBJOptima; private String argumentos[]; public Datos(String a[]) { argumentos=a; NumEstMin = Integer.valueOf(argumentos[1].trim()).intValue(); NumEstMax = Integer.valueOf(argumentos[2].trim()).intValue();

32

OBJOptima = Integer.valueOf(argumentos[3].trim()).intValue(); } public void importaDatos(){ try{ //Lectura del número de tareas (NumTareas) BufferedReader inbr = new BufferedReader(

new FileReader(argumentos[0])); NumTareas = Integer.valueOf(inbr.readLine().trim()).intValue(); //Lectura de los tiempos de las tareas (Tiempos[]) Tiempos = new int[NumTareas+1]; for(int i=1;i<=NumTareas;i++){ Tiempos[i]=

(Integer.valueOf(inbr.readLine().trim()).intValue()); } //Cálculo del número máximo de sucesores ID //y relleno MatrizSucI inbr.mark(1000000); MatrizSucI = new int[NumTareas+1][NumTareas+1]; int NumSucID=0; NumSucID = getNumSucID(inbr); //Inicilizar la matriz ListaPred y ListaSuc ID inicializaMatrices(NumSucID, ListaSucID, ListaPredID); //Se llena la lista de sucesores y precedesores ID inbr.reset(); llenaListaID(inbr, NumSucID); inbr.close(); //Cálculo del número máximo de sucesores DI int NumSucDI = 0; NumSucDI = getNumSucDI(); //Inicializa la matriz ListaPred Y ListaSuc ID inicializaMatrices(NumSucDI, ListaSucDI, ListaPredDI); //Se llena la lista de sucesores y predecesores DI llenaListaDI(NumSucDI, NumSucID); //Calcula la suma total de tiempos TiempoTotal = sumaTiempos(); } catch(EOFException e) { System.out.println("End of stream encountered"); } catch(FileNotFoundException e) { System.out.println("File Not Found:" + argumentos[0]); } catch(IOException e){ System.out.println("IO Exception"); }

33

} //Método que devuelve el número máximo de sucesores ID //a partir del stream de lectura directo del fichero public int getNumSucID(BufferedReader inbr) throws IOException { String inString = inbr.readLine(); StringTokenizer st = new StringTokenizer(inString); for(int i=1; i<=NumTareas ; i++) MatrizSucI[i][i] = 1; int a, b, aux, NumSucID=0, NumSucAux=1; a = Integer.valueOf(st.nextToken().trim()).intValue(); aux = Integer.valueOf(st.nextToken().trim()).intValue(); MatrizSucI[a][aux]=1; inString = inbr.readLine(); st = new StringTokenizer(inString); b=Integer.valueOf(st.nextToken().trim()).intValue(); aux = Integer.valueOf(st.nextToken().trim()).intValue(); while(aux != -1){ MatrizSucI[b][aux]=1; if(a==b){ NumSucAux++; } else { a=b; if(NumSucAux>NumSucID){ NumSucID=NumSucAux; } NumSucAux=1; } inString = inbr.readLine(); st = new StringTokenizer(inString); b = Integer.valueOf(st.nextToken().trim()).intValue(); aux = Integer.valueOf(st.nextToken().trim()).intValue(); } if(NumSucAux > NumSucID) NumSucID = NumSucAux; return(NumSucID); } //Inicializa a cero todos los valores de las

//Listas de Sucesores y Predecedorestanto de ID como de DI public void inicializaMatrices(int NumSuc, int ListaSuc[][],

int ListaPred[]) { ListaSuc = new int[NumTareas+1][NumSuc]; ListaPred = new int[NumTareas+1];

34

for(int i=0; i<=NumTareas; i++){ ListaPred[i]=0; for(int j=0;j<=(NumSuc-1);j++) ListaSuc[i][j]=0; } } //Crea y llena las listas de predecesores y sucesores a partir del //stream de entrada del fichero sabiendo el número máximo de sucesores. public void llenaListaID(BufferedReader inbr, int NumSuc)

throws IOException { ListaSucID = new int[NumTareas+1][NumSuc]; ListaPredID = new int[NumTareas+1]; String inString = inbr.readLine(); StringTokenizer st = new StringTokenizer(inString); int a = Integer.valueOf(st.nextToken().trim()).intValue(); int b = Integer.valueOf(st.nextToken().trim()).intValue(); int aux; int cont=0; while(a != -1){ ListaSucID[a][cont]=b; ListaPredID[b]++; aux = a; inString = inbr.readLine(); st = new StringTokenizer(inString); a = Integer.valueOf(st.nextToken().trim()).intValue(); b = Integer.valueOf(st.nextToken().trim()).intValue(); if(a==aux) cont++; else cont=0; } } //Calcula el número máximo de sucesores de DI una vez rellenadas las //listas de sucesores y predecesores de ID. public int getNumSucDI() { int NumSucDI=0; for(int i=1; i<=NumTareas;i++){ if(ListaPredID[i]>NumSucDI) NumSucDI = ListaPredID[i]; } return (NumSucDI); }

35

//Crea y llena las listas de sucesores y predecesores de ID una vez //se tienen las de DI. public void llenaListaDI(int NumSucDI, int NumSucID) { ListaSucDI = new int[NumTareas+1][NumSucDI]; ListaPredDI = new int[NumTareas+1]; int cont[] = new int[NumTareas+1]; for(int i=0; i<=(NumSucDI-1);i++) cont[i]=0; for(int i=1;i<=NumTareas;i++){ for(int j=0;j<=(NumSucID-1);j++){ if(ListaSucID[i][j] != 0){ ListaSucDI[ListaSucID[i][j]][cont[ListaSucID[i][j]]]=i; ListaPredDI[i]++; cont[ListaSucID[i][j]]++; } } } } public static int getNumTareas() { return NumTareas; } public int sumaTiempos() { TiempoMax=0; int suma = 0; for(int i=1; i<=NumTareas; i++){ suma += Tiempos[i]; if (Tiempos[i]>TiempoMax) TiempoMax = Tiempos[i]; } return suma; } }

1.2.14 MatrizPesos

public class MatrizPesos { static int MatrizID[][]; static int MatrizDI[][]; static int MatrizSuc[][]; final static void inicializa() { calculoMatrizSuc(); inicializaID(); inicializaDI();

36

actualizaPesoAzar("ID"); actualizaPesoAzar("DI"); } final static void inicializaID() { //La matriz MatrizID contiene en la posicion [i][j] el peso //de la tarea j segun el criterio i segun el grafo directo MatrizID = new int[15][Datos.getNumTareas()+1]; peso1ID(); CotasTC cotas = new CotasTC(); //El cálculo de algunos pesos cotas.calculoCotasIniciales(); //requieren conocer la cotaMaxTC peso2ID(); peso3ID(); peso4ID(); peso5ID(); peso6ID(); peso7ID(); peso8ID(); peso9ID(); peso10ID(); peso11ID(); peso12ID(); peso13ID(); ConstruirMatrizPesos(MatrizID); } final static void inicializaDI() { //La matriz MatrizDI contiene en la posicion [i][j] el peso //de la tarea j segun el criterio i segun el grafo inverso MatrizDI = new int[15][Datos.getNumTareas()+1]; peso1DI(); peso2DI(); peso3DI(); peso4DI(); peso5DI(); peso6DI(); peso7DI(); peso8DI(); peso9DI(); peso10DI(); peso11DI(); peso12DI(); peso13DI(); ConstruirMatrizPesos(MatrizDI); } //Algoritmo de ordenacion rapida para estandarizar los pesos public static int[][] Quicksort (int a[][], int izq, int der) { int indiceTareaAux,indicePesoAux, i , j , k ; if(izq < der){

37

i = izq; //Extremo izquierdo del vector o j = der; //extremo derecho del vector numero de componentes k = (int) ((izq+der)/2); //Punto que se utiliza como pivote en int pivote =a[k][1]; //la variable pivote se coloca el peso do { while((a[i][1] < pivote) ) i++; while((a[j][1] > pivote) ) j--; if (i <= j ){ indiceTareaAux =a[j][0]; indicePesoAux = a[j][1]; a[j][1] = a[i][1]; a[j][0] = a[i][0]; a[i][0] = indiceTareaAux; a[i][1] = indicePesoAux; i++; j--; } }while (i < j); a = Quicksort (a, izq, j); a = Quicksort (a, i, der); } return a; } //A este método se le pasa las tareas ordenadas convenientemente en //función de sus pesos, y los transforma a la forma estandar (todos //positivos y mayores que o)para el cálculo de los índices de decisión final static void ConstruirMatrizPesos(int MatrizPes[][]) { //Al método quicksort se le pasa la tarea y su peso //que se guarda en aux1[i][j], el índice de //la tarea se guarda en la columna i y el peso en la j int n=Datos.getNumTareas(); int [][] aux = new int [n+1][2]; for(int heuristica=1; heuristica <= 14 ; heuristica++){ for(int tarea=1 ; tarea <= n; tarea++) { aux[tarea][0] = tarea; aux[tarea][1] = MatrizPes[heuristica][tarea]; } //Se ordena el vector por pesos aux = Quicksort (aux, 1, n); //Se transforman los pesos MatrizPes[heuristica][aux[n][0]] = n; for(int i=n ; i>1; i--){ if(aux[i-1][1] == aux[i][1]) MatrizPes[heuristica][aux[i-1][0]] =

MatrizPes[heuristica][aux[i][0]]; else if(aux[i-1][1] < aux[i][1]) MatrizPes[heuristica][aux[i-1][0]] = i-1; else System.out.println("error al calcular el peso "+

": los pesos no se han ordenado bien"); } } }

38

public static void actualizaPesoAzar(String s) { int inferior, superior, aleatorio; int aux[]= new int[Datos.getNumTareas()]; //Se rellena el vector para despues extraer los numero de dicho // vector utilizando el azar no para obtener directamente el numero //sino a traves de los indices, los cuales se escogeran al azar inferior = 0; superior = Datos.getNumTareas(); for(int i=0; i<=Datos.getNumTareas()-1; i++) aux[i]=i+1; if (s.equals("ID")){ for(int i=1; i<=Datos.getNumTareas(); i++){ aleatorio=Azar.nextInt(inferior, superior-1); MatrizID[14][i] = aux[aleatorio]; aux[aleatorio]= aux[superior-1]; superior--; } } else if(s.equals("DI")){ for(int i=1; i<=Datos.getNumTareas(); i++){ aleatorio=Azar.nextInt(inferior, superior-1); MatrizDI[14][i] = aux[aleatorio]; aux[aleatorio]= aux[superior-1]; superior--; } MatrizDI[14][Datos.getNumTareas()] = aux[0]; } else System.out.println ("Error al leer parametro sentido en el

fichero opciones"); } final static void calculoMatrizSuc() //Cálculo de la matriz de

//sucesores totales { int MatrizSucAux[][]; int n=Datos.getNumTareas(); MatrizSuc = new int[n+1][n+1]; MatrizSucAux = new int[n+1][n+1]; int fila, columna, i, j, sumafila,aux,aux2; //Inicializar la matriz MatrizSuc con MatrizSucI for(fila=1 ;fila<=n ;fila++){

for(columna=1 ;columna<=n ;columna++) MatrizSuc[fila][columna]=Datos.MatrizSucI[fila][columna]; }

//En la iteracion k se calcula el producto de la //matriz se sucesores MatrizSuc por ella misma sumafila=0; aux2=1; //Se ejecuta una nueva iteración si la suma de las diferencias

39

//entre los componentes de la iteración k i la k-1 (aux2) //es igual a cero

while(aux2>0){ aux2=0; for(fila=1 ;fila<=Datos.getNumTareas() ;fila++){

for (columna=1 ;columna<=Datos.getNumTareas() ;columna++){ i=1; sumafila=0; while (i <= Datos.getNumTareas()){ aux=MatrizSuc[fila][i]*MatrizSuc[i][columna]; sumafila=sumafila+aux; i=i+1; } //Se cambian los componentes diferentes de 0

//por el valor 1 if(sumafila > 0) sumafila=1; if(sumafila < 0) System.out.println("error al calcular la matriz de

sucesores totales"); //Se comprueba si algun componente de la matriz // MatrizSuc ha cambiado respecto a la

//iteracion anterior aux2=aux2+Math.abs((sumafila-

MatrizSuc[fila][columna])); MatrizSucAux[fila][columna]=sumafila; }

} // copiar la matriz auxliar en la matriz MatrizSuc for(fila=1 ;fila<=Datos.getNumTareas() ;fila++){ for(columna=1 ;columna<=Datos.getNumTareas() ;columna++) MatrizSuc[fila][columna]=MatrizSucAux[fila][columna]; } } } // CONSTRUCCION DE LA MATRIZ DE PESOS ORIGINALES DE IZQUIERDA A DERECHA final static void peso1ID() { int n=Datos.getNumTareas(); for (int tarea=1; tarea<=n; tarea++) { MatrizID[1][tarea] = Datos.Tiempos[tarea]; } } final static void peso2ID(){ int n=Datos.getNumTareas(); for(int tarea=1; tarea<=n ; tarea++){ MatrizID[2][tarea] = Datos.ListaPredDI[tarea]; //El número de sucesores ID es el de predecesores DI } } final static void peso3ID(){

40

int n=Datos.getNumTareas(); int peso3; for (int tarea=1; tarea<=n; tarea++) { peso3=0; for (int sucesor=1; sucesor<=n ; sucesor++) { if (MatrizSuc[tarea][sucesor] == 1) peso3=peso3+1; } MatrizID[3][tarea]=peso3-1;

//la matriz de sucesores tambien incluye en la diagonal //el valor 1, por lo tanto hay que restarselo

} } final static void peso4ID(){ int n=Datos.getNumTareas(); int peso4; for (int tarea=1; tarea<=n ; tarea++) { peso4=0; for (int sucesor=1; sucesor<=n ; sucesor++) { if (MatrizSuc[tarea][sucesor] == 1) peso4=peso4+Datos.Tiempos[sucesor]; } MatrizID[4][tarea]=peso4; } } final static void peso5ID(){ int n=Datos.getNumTareas(); int tarea=1; try { for(tarea=1; tarea<=n; tarea++) MatrizID[5][tarea]=(100*(MatrizID[4][tarea])/

((MatrizID[3][tarea])+1)); } catch (ArithmeticException e){ System.out.println(tarea+" peso 5"); } } final static void peso6ID(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizID[6][tarea]=

(int)Math.ceil(((double)(MatrizID[4][tarea])/ (double)(CotasTC.CotaMaxTC)))-n-1;

} } catch (ArithmeticException e){ System.out.println(tarea+" peso 6"); } } final static void peso7ID(){ int n=Datos.getNumTareas(); int tarea=1; try {

41

for (tarea=1; tarea<=n ; tarea++) MatrizID[7][tarea]=(100*(MatrizID[6][tarea]))/

(MatrizID[3][tarea]+1); } catch (ArithmeticException e){ System.out.println(tarea+" peso 7"); } } final static void peso8ID(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) MatrizID[8][tarea]=(1000*(MatrizID[1][tarea]))/

(-MatrizID[6][tarea]); } catch (ArithmeticException e){ System.out.println(tarea+" peso 8"); } } final static void peso9ID(){ int n=Datos.getNumTareas(); int tarea=1; int peso9, predecesor; try { for (tarea=1; tarea<=n ; tarea++) { peso9=0; for ( predecesor=1; predecesor<=n ; predecesor++) { if (MatrizSuc[predecesor][tarea] == 1) peso9=peso9+Datos.Tiempos[predecesor]; } MatrizID[9][tarea]=-(int)Math.ceil((double)peso9/

(double) CotasTC.CotaMaxTC); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 9"); } } final static void peso10ID(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) {

MatrizID[10][tarea]=MatrizID[6][tarea]-MatrizID[9][tarea]; // +(-UB(i))-(-LB(i))

} } catch (ArithmeticException e){ System.out.println(tarea+" peso 10"); } } final static void peso11ID(){ int n=Datos.getNumTareas(); int tarea=1;

42

try { for (tarea=1; tarea<=n ; tarea++) { MatrizID[11][tarea]=(100*(MatrizID[3][tarea])/

(-MatrizID[10][tarea])); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 11"); } } final static void peso12ID(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizID[12][tarea] = MatrizID[1][tarea] +

MatrizID[3][tarea]; } } catch (ArithmeticException e){ System.out.println(tarea+" peso 12"); } } final static void peso13ID(){ int n=Datos.getNumTareas(); int i,tarea, predecesor, aux; //Se inicilizan los indices K&W los niveles se

//establecen hacia atras, del final al principio

for (i=1; i<=n ; i++) MatrizID[13][i]=1; aux=0; while (aux==0) { aux=1; //En este caso se empieza por la ultima tarea para disminuir

//el numero de pasadas y asi aumentar la velocidad for (tarea=n; tarea>0 ; tarea--) { for( predecesor=1; predecesor<=n ; predecesor++) { //Para todas las tareas que tengan un predecesor inmediato if ((Datos.MatrizSucI[predecesor][tarea] == 1) &&

(tarea!=predecesor)){ //Como los niveles de calculan hacia atras, se //utiliza la matriz de predecesores si la tarea

//tiene un predecesor inmediato con un nivel menor o //igual que dicha tarea, aumentar el nivel del //predecesor en 1

if(MatrizID[13][tarea]>=MatrizID[13][predecesor]){ MatrizID[13][predecesor]=MatrizID[13][tarea]+1; aux=0; } } } } } }

43

// CONSTRUCCION DE LA MATRIZ DE PESOS ORIGINALES DE DERECHA A IZQUIERDA final static void peso1DI(){ int n=Datos.getNumTareas(); for (int tarea=1; tarea<=n; tarea++) { MatrizDI[1][tarea]= Datos.Tiempos[tarea];

//La fila , el numero 1, representa el indice de peso } } final static void peso2DI(){ int n=Datos.getNumTareas(); for(int tarea=1; tarea<=n ; tarea++) MatrizDI[2][tarea] = Datos.ListaPredID[tarea]; } final static void peso3DI(){ int n=Datos.getNumTareas(); int peso3; for (int tarea=1; tarea<=n; tarea++) { peso3=0; for (int sucesor=1; sucesor<=n ; sucesor++) { if (MatrizSuc[sucesor][tarea] == 1) peso3=peso3+1; } MatrizDI[3][tarea]=peso3-1;

//La matriz de sucesores tambien incluye en la diagonal //el valor 1, por lo tanto hay que restarselo

} } final static void peso4DI(){ int n=Datos.getNumTareas(); int peso4; for (int tarea=1; tarea<=n ; tarea++) { peso4=0; for (int sucesor=1; sucesor<=n ; sucesor++) { if (MatrizSuc[sucesor][tarea] == 1) peso4=peso4+Datos.Tiempos[sucesor]; } MatrizDI[4][tarea]=peso4; } } final static void peso5DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for(tarea=1; tarea<=n; tarea++) { MatrizDI[5][tarea]=(100*(MatrizDI[4][tarea])/

((MatrizDI[3][tarea])+1)); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 5 DI");

44

} } final static void peso6DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizDI[6][tarea]=

(int)Math.ceil(((double)(MatrizDI[4][tarea])/ (double)(CotasTC.CotaMaxTC)))-n-1;

//se ha de calcular en algun sitio una cota maxima //del tiempo de ciclo

} } catch (ArithmeticException e){ System.out.println(tarea+" peso 6 DI"); } } final static void peso7DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizDI[7][tarea]=(100*(MatrizDI[6][tarea]))/

(MatrizDI[3][tarea]+1); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 7 DI"); } } final static void peso8DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizDI[8][tarea]=

(1000*(MatrizDI[1][tarea]))/(-MatrizDI[6][tarea]); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 8 DI"); } } final static void peso9DI(){ int n=Datos.getNumTareas(); int tarea=1; int peso9, predecesor; try { for (tarea=1; tarea<=n ; tarea++) { peso9=0; for ( predecesor=1; predecesor<=n ; predecesor++) { if (MatrizSuc[tarea][predecesor] == 1) peso9=peso9+Datos.Tiempos[predecesor]; }

45

MatrizDI[9][tarea]= -(int)Math.ceil((double)peso9/(double)CotasTC.CotaMaxTC);

} } catch (ArithmeticException e){ System.out.println(tarea+" peso 9 DI"); } } final static void peso10DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) {

MatrizDI[10][tarea]=MatrizDI[6][tarea]-MatrizDI[9][tarea]; // +(-UB(i))-(-LB(i))

} } catch (ArithmeticException e){ System.out.println(tarea+" peso 10 DI"); } } final static void peso11DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizDI[11][tarea]=(100*(MatrizDI[3][tarea])/

(-MatrizDI[10][tarea])); } } catch (ArithmeticException e){ System.out.println(tarea+" peso 11"); } } final static void peso12DI(){ int n=Datos.getNumTareas(); int tarea=1; try { for (tarea=1; tarea<=n ; tarea++) { MatrizDI[12][tarea] = MatrizDI[1][tarea] +

MatrizDI[3][tarea]; } } catch (ArithmeticException e){ System.out.println(tarea+" peso 12"); } } final static void peso13DI(){ int n=Datos.getNumTareas(); int i,tarea, predecesor, aux; //Inicializamos los indices K&W los niveles se establecen

//hacia atras, del final al principio for (i=1; i<=n ; i++) MatrizDI[13][i]=1; aux=0;

46

while (aux==0) { aux=1; //En este caso se empieza por la ultima tarea para disminuir

//el numero de pasadas y asi aumentar la velocidad for (tarea=1 ; tarea <= n ; tarea++) { for( predecesor=1; predecesor<=n ; predecesor++) { if ((Datos.MatrizSucI[tarea][predecesor] == 1) &&

(tarea != predecesor) ){ if(MatrizDI[13][tarea]>=MatrizDI[13][predecesor]){ MatrizDI[13][predecesor]=MatrizDI[13][tarea]+1; aux=0; } } } } } } public static void actualizaPesos() { peso6ID(); peso7ID(); peso8ID(); peso9ID(); peso10ID(); peso11ID(); peso6DI(); peso7DI(); peso8DI(); peso9DI(); peso10DI(); peso11DI(); } }

1.2.15 CotasTC

public class CotasTC { static int CotaMinTC; static int CotaMaxTC; public CotasTC(){ CotaMaxTC = Datos.TiempoTotal; } public void calculoCotasIniciales() { CotaMinTC = calculoMinTC(); calculoMaxTC(); } public int calculoMinTC() { int tiempoMax = Datos.Tiempos[1];

47

int sumaTiempos = tiempoMax; for(int i=2; i<=Datos.NumTareas ; i++){ sumaTiempos += Datos.Tiempos[i]; if(Datos.Tiempos[i]>tiempoMax) tiempoMax = Datos.Tiempos[i]; } if(tiempoMax <= (sumaTiempos/Datos.NumEstMax)) return (sumaTiempos/Datos.NumEstMax); else return tiempoMax; } public void calculoMaxTC() { int tareapos[] = new int[2]; Ristra ristra = new Ristra("ID"); NextTareaInicial next = new NextTareaInicial("ID"); for(int i=1; i<=Datos.NumTareas; i++){ tareapos = next.getTarea(1, ristra.ultimaT); ristra.actualizaRistraT(tareapos[0]); next.lista.actualizaListas(tareapos); } int Ristra[] = new int[Datos.NumTareas+1]; Ristra = ristra.getRistraT(); int TC2 = CotaMinTC; int tacum, tasig, TCajust2, n2, TCnext; int i, r; int marca, cota2; do{ //loop de tiempos de ciclo tacum = 0; tasig = 0; TCajust2 = 0; n2 = 1; r = 1; marca = 0; cota2 = 1; TCnext = 1000000000; do{ //loop de r i = Ristra[r]; tacum += Datos.Tiempos[i]; if(tacum > TC2){ if((tacum-Datos.Tiempos[i]) > TCajust2) TCajust2 = tacum-Datos.Tiempos[i]; if(tacum < TCnext) TCnext = tacum; tasig = tasig + tacum - Datos.Tiempos[i]; tacum = Datos.Tiempos[i]; n2 += 1; if((n2-1+(int)Math.floor((double)(Datos.TiempoTotal-

tasig)/TC2)) > Datos.NumEstMin) cota2 = 0; } if(r==Datos.NumTareas)

48

marca = 1; r++; } while((r<=Datos.NumTareas) && (n2<=Datos.NumEstMin) &&

(cota2>0)); if(tacum>TCajust2) {TCajust2 = tacum;} if(TC2 == Datos.TiempoTotal) {TCajust2 = TC2;} if(n2 > Datos.NumEstMin){ TC2 = TCnext; } else if(n2 == Datos.NumEstMin){ if(marca == 1){ if(TCajust2<CotaMaxTC) CotaMaxTC = TCajust2; TC2 = Datos.TiempoTotal+1; } else if(marca == 0){ if((Datos.TiempoTotal-tasig)<=TC2){ if((Datos.TiempoTotal-tasig)>TCajust2) TCajust2 = Datos.TiempoTotal-tasig; if(TCajust2<CotasTC.CotaMaxTC) CotaMaxTC = TCajust2; TC2 = Datos.TiempoTotal+1; } else if((Datos.TiempoTotal-tasig)>TC2) TC2 = TCnext; } } else if(n2<Datos.NumEstMin){ if(marca == 1){ TC2 = Datos.TiempoTotal+1; CotaMaxTC = TCajust2; } else if(marca == 0){ if((n2-1+(int)Math.floor((double)(Datos.TiempoTotal-

tasig)/TC2)) > Datos.NumEstMin) TC2 = TCnext; else if((n2-1+(int)Math.floor(

(double)(Datos.TiempoTotal-tasig)/TC2)) <= Datos.NumEstMin) { TC2 = Datos.TiempoTotal+1; CotaMaxTC = Datos.TiempoTotal; } } } } while(TC2 <= Datos.TiempoTotal); } }

1.2.16 CotaSALBPE

public class CotaSalbpE { int Cota1; int Cota2; int Cota3;

49

int Cota4; int [] TCicloMin; //En este vector se guarda para cada numero de //estaciones(SALBP-2)su cota minima de tiempo de //ciclo necesaria para empezar en el mayor

//tiempo de ciclo posible la cota 4 static int CotaSalbpE; public CotaSalbpE() { TCicloMin = new int [Datos.NumEstMax-Datos.NumEstMin+1]; CalculoCota1(); System.out.println("cota1 : "+Cota1); CalculoCota2(); System.out.println("cota2 : "+Cota2); CalculoCota3(); System.out.println("cota3 : "+Cota3); CalculoCota4(); System.out.println("cota4 : "+Cota4); CotaSalbpE = maximo(Cota1, Cota2, Cota3, Cota4); System.out.println("CotaSalbpE : "+ CotaSalbpE); } public void CalculoCota1() { Cota1 = Datos.TiempoTotal; int aux; for (int i=0; i <= (Datos.NumEstMax-Datos.NumEstMin); i++){ aux=Datos.TiempoTotal/(Datos.NumEstMin+i); if (aux >= Datos.TiempoMax) TCicloMin[i] = aux; else TCicloMin[i] = Datos.TiempoMax; } } public void CalculoCota2() { Cota2 = Datos.TiempoMax * Datos.NumEstMin; } public void CalculoCota3() { int Cota3Aux,k, suma, sumaAux, estaciones; int n = Datos.getNumTareas(); int [][] auxTiempos = new int [n+1][2]; int [][] auxTiempos2 = new int [n+1][2]; //Se copian los tiempos en en vector auxTiempos ordenados de menor //a mayor y comenzando por la posicion for (int j=1 ; j <= n; j++){ auxTiempos[j][0]= j; auxTiempos[j][1]= Datos.Tiempos[j]; } //Se ordena el vector por pesos auxTiempos = MatrizPesos.Quicksort(auxTiempos, 0, n-1); //Se invierte el orden para que la tareas esten en orden //decreciente de tiempos

50

for (int t=1 ; t <= n; t++){ auxTiempos2[t][0] = auxTiempos[n-t+1][0]; auxTiempos2[t][1] = auxTiempos[n-t+1][1]; } Cota3=1000000000; for (estaciones = Datos.NumEstMin; estaciones <= Datos.NumEstMax;

estaciones++){ k=1; suma = 0; while ( k <= (int) (Math.floor((double)((n-1)/estaciones)))){ //Ver sumatorio libro Scholl pag 56 sumaAux=0; for (int i = 0; i<=k; i++) sumaAux = sumaAux + auxTiempos2[(k*estaciones+1-i)][1]; if (sumaAux > suma) suma = sumaAux; k++; } if ( suma*estaciones < Cota3) Cota3 = suma*estaciones; if (suma > TCicloMin[estaciones-Datos.NumEstMin]) TCicloMin[estaciones-Datos.NumEstMin] = suma; } } public void CalculoCota4() { int estaciones; int tiempoCiclo; int tiempoAcum; int tarea; boolean finTareas = false; boolean finTiempoCiclo = false; int [] tiempoPredecesores = new int[Datos.NumTareas+1]; int [] EarliestStation = new int[Datos.NumTareas+1]; int [] LatestStation = new int[Datos.NumTareas+1]; //Se calcula el numerador de la formula de la EarliestStation //ya que es fijo para todos los tiempos de ciclo

for (tarea=1; tarea <= Datos.NumTareas; tarea++) { tiempoAcum=0; for (int predecesor=1;predecesor<=Datos.NumTareas

;predecesor++){ if (MatrizPesos.MatrizSuc[predecesor][tarea] == 1) tiempoAcum=tiempoAcum+Datos.Tiempos[predecesor]; } tiempoPredecesores[tarea] = tiempoAcum; } Cota4=1000000000; for (estaciones = Datos.NumEstMin; estaciones <= Datos.NumEstMax;

estaciones++){ //Se inicializa el tiempo de ciclo tiempoCiclo = TCicloMin[estaciones-Datos.NumEstMin];

51

//Se calcula la EarliestStation y la LatestStation //para cada tarea

while (tarea <= Datos.NumTareas){ EarliestStation[tarea] =(int)Math.ceil((double) tiempoPredecesores[tarea]/ (double) tiempoCiclo); LatestStation[tarea] = Datos.NumTareas+1-

(int)Math.ceil( ((double)(MatrizPesos.MatrizID[4][tarea])/ (double)(tiempoCiclo)));

if (EarliestStation[tarea] > LatestStation[tarea]){ tiempoCiclo = tiempoCiclo+1; tarea = 1; } else tarea=tarea+1; } if ( tiempoCiclo*estaciones < Cota4) Cota4 = tiempoCiclo*estaciones; } } public int maximo(int cota1,int cota2, int cota3, int cota4) { int maximo; maximo = Math.max(cota1, cota2); maximo = Math.max(maximo, cota3); maximo = Math.max(maximo, cota4); return maximo; } }

1.2.17 Azar

import java.util.*; public class Azar extends Random { static Random aleatorio;

public static void semilla() { aleatorio = new Random(); }

public static int nextInt (int inferior, int superior) { if (superior <= inferior-1) System.out.println("error al utilizar el metodo nextInt

de la clase Azar: inferior > que superior"); int i; i = aleatorio.nextInt(); i = inferior + (Math.abs(i)) % (superior- inferior +1); return i; } }

52

1.2.18 MejorSolucion

public class MejorSolucion { static int OBJ; static int N; static int TC; static int Ristra[]; static String sentidoHormiga; static String sentidoEval; static int OBJInicial; public static void inicializa() { OBJ = 1000000000; N = 1000000000; TC = 1000000000; Ristra = new int[Datos.NumTareas+1]; } }

1.2.19 Cronometro

import java.util.*; public class Cronometro { Calendar i, f; int ihoras, iminutos, isegundos; int fhoras, fminutos, fsegundos; public Cronometro() { } public void inicio() { i = Calendar.getInstance(); ihoras = i.get(Calendar.HOUR_OF_DAY); iminutos = i.get(Calendar.MINUTE); isegundos = i.get(Calendar.SECOND); } public void fin() { f = Calendar.getInstance(); fhoras = f.get(Calendar.HOUR_OF_DAY); fminutos = f.get(Calendar.MINUTE); fsegundos = f.get(Calendar.SECOND); }

53

public int tiempo() //Devuelve el tiempo en segundos { int tiempo = -1; if(f.get(Calendar.DAY_OF_YEAR) == i.get(Calendar.DAY_OF_YEAR)){ tiempo = (fhoras - ihoras)*3600 + (fminutos - iminutos)*60 + (fsegundos - isegundos); } else if((f.get(Calendar.DAY_OF_YEAR) –

i.get(Calendar.DAY_OF_YEAR)) == 1){ tiempo = (fhoras + (24-ihoras))*3600 + (fminutos - iminutos)

*60 + (fsegundos - isegundos); } return tiempo; } }

1.2.20 Salida

import java.io.*; import java.math.*; import java.util.*; import java.text.*; public class Salida { String Fichero; PrintWriter outbr, tablabr, distrbr; static int numSol; //Número de soluciones evaluadas int OBJInicial; public Salida(String f) { try{ //Fichero de salida con la evolución del porblema outbr = new PrintWriter(new FileWriter(

"Evol_"+f+"-"+Datos.NumEstMin+"-"+Datos.NumEstMax+".dat", true));

//Tabla de resultados tablabr = new PrintWriter(new FileWriter(

"Tabla_"+f+"-"+Datos.NumEstMin+"-"+Datos.NumEstMax+".dat", true));

//Distribución de tareas: solución final encontrada distrbr = new PrintWriter(new FileWriter(

"Distr_"+f+"-"+Datos.NumEstMin+"-"+Datos.NumEstMax+".dat", true));

numSol = 0; } catch(FileNotFoundException e) { System.out.println("File Not Found");

54

} catch(IOException e){ System.out.println("IO Exception"); } } public void acumulaSalida(Subcolonia sub) { outbr.print(MejorSolucion.OBJ+"\t"); int mejorSub = sub.PaqueteOBJ[0]; for(int ant=1; ant<=13; ant++){ if(sub.PaqueteOBJ[ant] < mejorSub) mejorSub = sub.PaqueteOBJ[ant]; } outbr.print(mejorSub+"\t"); double desviacion=0.0, media=0.0; for(int ant=0; ant<=13; ant++) media += (double)sub.PaqueteOBJ[ant]; media = media/14; for(int ant=0; ant<=13; ant++) desviacion += Math.pow((double)sub.PaqueteOBJ[ant]-media,2.0); desviacion = Math.pow(desviacion/13, 0.5); outbr.println(desviacion); } public void tablaSalida(int numSubColonia, int tiempo) { NumberFormat N = NumberFormat.getInstance(); N.setMinimumFractionDigits(3); N.setMaximumFractionDigits(3); tablabr.print(Datos.OBJOptima+"$"); //OBJ óptima del juego de datos tablabr.print(OBJInicial+"$"); tablabr.print(MejorSolucion.OBJ+"$"); tablabr.print(MejorSolucion.N+"$"); tablabr.print(MejorSolucion.TC+"$"); double discrepancia; discrepancia = (((double)(MejorSolucion.OBJ –

Datos.OBJOptima))/(double)(Datos.OBJOptima))*100.0; tablabr.print(N.format(discrepancia)+"$");

//Discrepancia relativa a la solución óptima double mejora; mejora = (((double)(OBJInicial –

MejorSolucion.OBJ))/(double)(OBJInicial))*100.0; tablabr.print(N.format(mejora)+"$"); tablabr.print(numSubColonia+"$"); tablabr.print(numSol+"$"); if(tiempo == 0) tablabr.println("1");

55

if(tiempo != 0) tablabr.println(tiempo); } public void rellenaBlancos(int ultima) { for(int i=(ultima+1); i<=Opciones.limitacion; i++) outbr.println(); } public void estacionesSalida() { if(MejorSolucion.sentidoHormiga.equals("DI")) invertirRistra(); if(MejorSolucion.sentidoEval.equals(MejorSolucion.sentidoHormiga)) evaluacionNormal(); else evaluacionMarcas(); } public void invertirRistra() { int aux; for(int r=1; r<=(Datos.NumTareas/2); r++){ aux = MejorSolucion.Ristra[r]; MejorSolucion.Ristra[r] =

MejorSolucion.Ristra[Datos.NumTareas-r+1]; MejorSolucion.Ristra[Datos.NumTareas-r+1] = aux; } } public void evaluacionNormal() { int n = 1; int tacum = 0; int cont = 0; int tmuerto[] = new int[MejorSolucion.N+1]; distrbr.println("@inicio"); for(int r=1; r<=Datos.NumTareas; r++){ tacum += Datos.Tiempos[MejorSolucion.Ristra[r]]; if(tacum > MejorSolucion.TC){ tmuerto[n] = MejorSolucion.TC -tacum +

Datos.Tiempos[MejorSolucion.Ristra[r]]; tacum = Datos.Tiempos[MejorSolucion.Ristra[r]]; n++; } }

56

tmuerto[n] = MejorSolucion.TC - tacum; n=1; distrbr.println("Estacion 1 (Tiempo muerto= "+tmuerto[1]+")"); tacum = 0; for(int r=1; r<=Datos.NumTareas; r++){ tacum += Datos.Tiempos[MejorSolucion.Ristra[r]]; if(tacum > MejorSolucion.TC){ tacum = Datos.Tiempos[MejorSolucion.Ristra[r]]; n++; distrbr.println(); distrbr.println(); distrbr.println("Estacion "+n+

" (Tiempo muerto= "+tmuerto[n]+")"); cont = 0; } distrbr.print("\t"+MejorSolucion.Ristra[r]); cont++; if((cont == 10) && r<Datos.NumTareas){ if(tacum+Datos.Tiempos[MejorSolucion.Ristra[r+1]] <=

MejorSolucion.TC){ cont = 0; distrbr.println(); } } } distrbr.println(); } public void evaluacionMarcas() { int marcas[] = new int[MejorSolucion.N+1];

//marcas[n] es la posicion donde acaba la estacion n int n = MejorSolucion.N; int tacum = 0; int cont = 0; int tmuerto[] = new int[MejorSolucion.N+1]; distrbr.println("@inicio"); for(int r=Datos.NumTareas; r>=1; r--){ tacum += Datos.Tiempos[MejorSolucion.Ristra[r]]; if(tacum > MejorSolucion.TC){ tmuerto[n] = MejorSolucion.TC -tacum +

Datos.Tiempos[MejorSolucion.Ristra[r]]; tacum = Datos.Tiempos[MejorSolucion.Ristra[r]]; marcas[n-1] = r; n--; } } tmuerto[n] = MejorSolucion.TC - tacum; marcas[0] = 0; marcas[MejorSolucion.N] = Datos.NumTareas;

57

for(n=1; n<=MejorSolucion.N; n++){ cont = 0; distrbr.println(); distrbr.println("Estacion "+n+

" (Tiempo muerto= "+tmuerto[n]+")"); for(int r=marcas[n-1]+1; r<=marcas[n]; r++){ distrbr.print("\t"+MejorSolucion.Ristra[r]); cont++; if((cont == 10) && r != marcas[n]){ cont = 0; distrbr.println(); } } distrbr.println(); } } public void escribeSalida() { outbr.close(); tablabr.close(); distrbr.close(); } }

58

CAPÍTULO 2: ALGORITMO DE LAS HORMIGAS CON

MEJORA LOCAL

59

2.1 DESCRIPCIÓN DEL PROGRAMA

Utiliza todas las clases del programa del apartado 1, añadiendo la clase MejoraLocal y reemplazando la clase Subcolonia para que sea capaz de llamar a la clase MejoraLocal cuando sea necesario.

60

2.2 LISTADO DE LOS OBJETOS

2.2.1 MejoraLocal

public class MejoraLocal { Ristra ristra; int numRistras; int r; static int mejorOBJ; int mejorTC; int mejorN; String sentido; String mejorSentidoEval; public MejoraLocal(Ristra ris, String s, int obj) { ristra = ris; r=0; mejorOBJ = obj; sentido = s; } public void inicia(int numRistras, String sentidoMejora) { if(sentidoMejora.equals("DI")){ invierte(); if(sentido.equals("ID")) sentido = "DI"; else sentido = "ID"; } for(int cont=1; cont<=numRistras; cont++){ intercambia(); compara(sentidoMejora); } if(sentidoMejora.equals("DI")) invierte(); } public void intercambia() { int aux; do{ if(r==Datos.NumTareas-1) r=0; r++; } while(factibilidad() == false); aux = ristra.RistraT[r]; ristra.RistraT[r] = ristra.RistraT[r+1]; ristra.RistraT[r+1] = aux; }

61

public boolean factibilidad() { //Factible si r+1 no es sucesor de r if((sentido.equals("ID")) &&

(MatrizPesos.MatrizSuc[ristra.RistraT[r]][ristra.RistraT[r+1]] == 1))

return false; else if((sentido.equals("DI")) &&

(MatrizPesos.MatrizSuc[ristra.RistraT[r+1]][ristra.RistraT[r]] == 1))

return false; else return true; } public void compara(String sentidoMejora) { ristra.evaluacionRistra(); int aux; if(ristra.eval.getObj() > mejorOBJ){ aux = ristra.RistraT[r]; ristra.RistraT[r] = ristra.RistraT[r+1]; ristra.RistraT[r+1] = aux; } if(ristra.eval.getObj() < mejorOBJ){ mejorOBJ = ristra.eval.getObj(); mejorN = ristra.eval.getNumEst(); mejorTC = ristra.eval.getTC(); if(sentidoMejora.equals("ID")) mejorSentidoEval = ristra.eval.mejorSentido; else { if(ristra.eval.mejorSentido.equals("ID")) mejorSentidoEval = "DI"; else mejorSentidoEval = "ID"; } } } public void invierte() { int aux; for(int r=1; r<=(Datos.NumTareas/2); r++){ aux = ristra.RistraT[r]; ristra.RistraT[r] = ristra.RistraT[Datos.NumTareas-r+1]; ristra.RistraT[Datos.NumTareas-r+1] = aux; } } }

62

2.2.2 Subcolonia

public class Subcolonia { int tamano; //1 ó 14 String Sentido; Hormiga ant; int numAnt = 0; double b; boolean marcaMejor = false; //true si la mejor hormiga mejora

//o iguala la OBJ global boolean marcaMejorSolo = false; //true si la mejor hormiga mejora

//la OBJ global boolean mejorado, igualado; static int mejorsubOBJ; static int maxsubTC; MejoraLocal mejora;

static int numSubcolonia; static int numMejora; //nº de mejora global boolean aplicaMejora; //true si se debe aplicar una mejora local static int numSubMejora; //nº mejora dentro de la subcolonia boolean lasPrimeras10; //Controla la mejora en las 10 primeras //subcolonias de hormigas //Atributos para la recolección de información int PaqueteRistras[][]; int PaqueteOBJ[]; int PaqueteN[]; int PaqueteTC[]; int auxRistra[]; int auxOBJ; int numSub; public Subcolonia(int t, String s, int n) { tamano = t; Sentido = s; PaqueteOBJ = new int[14]; PaqueteRistras = new int[14][Datos.NumTareas+1]; PaqueteN = new int[14]; PaqueteTC = new int[14]; MatrizPesos.actualizaPesoAzar(Sentido); mejorsubOBJ = 2000000000; maxsubTC = Datos.TiempoTotal; rastretes = Rastros.Tareas; numSub = n; igualado = false; mejorado = false; aplicaMejora = false; lasPrimeras10 = true;

63

} public void lanzaHormigas() { for(int i=1; i<=14; i++){ ant = new Hormiga(i, Sentido, Opciones.tipoHormiga); ant.construirSolucion(); recogeInformacion(); comparaInformacion(); numAnt++; } numSubcolonia++; if(aplicaMejora == true) numSubMejora++; } public void recogeInformacion() { for(int i=1; i<=Datos.NumTareas; i++) PaqueteRistras[numAnt][i] = ant.ristra.RistraT[i]; PaqueteOBJ[numAnt] = ant.ristra.eval.getObj(); PaqueteN[numAnt] = ant.ristra.eval.getNumEst(); PaqueteTC[numAnt] = ant.ristra.eval.getTC(); } public void comparaInformacion() { if((numSubcolonia <=10 || (numSubcolonia%30 == 0)) &&

lasPrimeras10 == true){ mejoraLocal("ID"); lasPrimeras10 = false; } if(PaqueteOBJ[numAnt] < MejorSolucion.OBJ){ MejorSolucion.OBJ = PaqueteOBJ[numAnt]; MejorSolucion.N = PaqueteN[numAnt]; MejorSolucion.TC = PaqueteTC[numAnt]; for(int i=1; i<=Datos.NumTareas; i++) MejorSolucion.Ristra[i] = PaqueteRistras[numAnt][i]; MejorSolucion.sentidoHormiga = Sentido; MejorSolucion.sentidoEval = ant.ristra.eval.mejorSentido; marcaMejorSolo = true; mejorado = true; } if(PaqueteOBJ[numAnt] <= MejorSolucion.OBJ){ marcaMejor = true; igualado = true; if((numMejora%2) != 0) mejoraLocal("ID"); else mejoraLocal("DI"); numMejora++;

64

aplicaMejora = true; } if(PaqueteOBJ[numAnt] < MejorSolucion.OBJ){ MejorSolucion.OBJ = PaqueteOBJ[numAnt]; MejorSolucion.N = PaqueteN[numAnt]; MejorSolucion.TC = PaqueteTC[numAnt]; for(int i=1; i<=Datos.NumTareas; i++) MejorSolucion.Ristra[i] = PaqueteRistras[numAnt][i]; MejorSolucion.sentidoEval = mejora.mejorSentidoEval; marcaMejorSolo = true; mejorado = true; } } public void actualizaRastros() { evaporaRastros(); actualizaTareas(); } public void actualizaTareas() { double unidadRastro[] = new double[15]; double sumaOBJ = 0; int tareaA, tareaB; if(tamano == 14){ //Dejan rastro todas las hormigas for(int i=0; i<=13; i++){ b = 100.0*(((double)(PaqueteOBJ[i])-

(double)(Datos.TiempoTotal))/ ((double)(Datos.TiempoTotal))); unidadRastro[i] = 1/(Math.pow(b, 1.0)); } for(int contAnt = 0; contAnt<=13; contAnt++){ tareaA = 0; for(int r=1; r<=Datos.NumTareas; r++){

//r = posición en la ristra tareaB = PaqueteRistras[contAnt][r]; Rastros.Tareas[tareaA][tareaB] +=

unidadRastro[contAnt]; tareaA = tareaB; } } } //Sólo dejan rastro las mejores hormigas int minOBJ[] = new int[14]; //Contiene las hormigas con mejor OBJ int limAnt = 0; minOBJ[0] = 0; for(int contAnt=1; contAnt<=13; contAnt++){

65

if(PaqueteOBJ[contAnt]<PaqueteOBJ[minOBJ[0]]){ minOBJ[0] = contAnt; limAnt = 0; } else if(PaqueteOBJ[contAnt]==PaqueteOBJ[minOBJ[0]]){ minOBJ[limAnt+1] = contAnt; limAnt++; } } if(marcaMejor == true){ //La mejor hormiga mejora

//o iguala la OBJ global for(int i=0; i<=limAnt; i++){ tareaA = 0; for(int r=1; r<=Datos.NumTareas; r++){ tareaB = PaqueteRistras[minOBJ[i]][r]; double maxRastro = 0.0; for(int j=0; j<=Datos.NumTareas; j++){

//Se busca el máximo rastro if(Rastros.Tareas[tareaA][j] > maxRastro) maxRastro = Rastros.Tareas[tareaA][j]; }

//Evaporación extra if(marcaMejorSolo == true){

for(int j=0; j<=Datos.NumTareas; j++){ Rastros.Tareas[tareaA][j] *=

(1-Opciones.evaporacionExtra); }

maxRastro *= Opciones.rastroExtra; if(numSubcolonia == 1) maxRastro *=Opciones.tamano;

} Rastros.Tareas[tareaA][tareaB] = maxRastro; tareaA = tareaB; } if(marcaMejorSolo == true){ double maxRastro = 0.0; for(int j=0; j<=Datos.NumTareas; j++){

//Se busca el máximo rastro if(Rastros.Tareas[tareaA][j] > maxRastro) maxRastro = Rastros.Tareas[tareaA][j];

}

//Evaporación extra de la fila de la //última tarea de la ristra

for(int pos=0; pos<=Datos.NumTareas; pos++){ Rastros.Tareas[tareaA][pos] *=

(1-Opciones.evaporacionExtra); }

maxRastro *= Opciones.rastroExtra; if(numSubcolonia == 1) maxRastro *=Opciones.tamano; Rastros.Tareas[tareaA][0] = maxRastro; marcaMejorSolo = false; //Ya no entra más, sólo evapora //la primera hormiga } }

66

} for(int i=0; i<=limAnt; i++){ b = 100.0*(((double)(PaqueteOBJ[minOBJ[i]])-

((double)(CotaSalbpE.CotaSalbpE)))/ ((double)(CotaSalbpE.CotaSalbpE))); double unidad = 1/(Math.pow(b, 2.0)); tareaA = 0; for(int r=1; r<=Datos.NumTareas; r++){ tareaB = PaqueteRistras[minOBJ[i]][r]; Rastros.Tareas[tareaA][tareaB] += unidad; tareaA = tareaB; } Rastros.Tareas[tareaA][0] += unidad; //Rastro entre la última

//tarea de la ristra y la //tarea 0 en sentido

//contrario } } public void evaporaRastros() { for(int i=0; i<=Datos.NumTareas; i++){ for(int j=0; j<=Datos.NumTareas; j++){ Rastros.Tareas[i][j] = Rastros.Tareas[i][j]*

(1.0-Opciones.evaporacion); } } } public void mejoraLocal(String sentidoMejora) { if(numSubcolonia >= 0 && numSubMejora <=80){ Hormiga antMejora =

new Hormiga(1, Sentido, Opciones.tipoHormiga); for(int i=1; i<=Datos.NumTareas; i++) antMejora.ristra.RistraT[i] = PaqueteRistras[numAnt][i]; mejora = new

MejoraLocal(antMejora.ristra, Sentido, PaqueteOBJ[numAnt]); mejora.inicia(2000, sentidoMejora); if(mejora.mejorOBJ < PaqueteOBJ[numAnt]){

PaqueteOBJ[numAnt] = mejora.mejorOBJ; PaqueteN[numAnt] = mejora.mejorN; PaqueteTC[numAnt] = mejora.mejorTC; for(int i=1; i<=Datos.NumTareas; i++) PaqueteRistras[numAnt][i] = mejora.ristra.RistraT[i]; }

67

if(mejora.mejorOBJ < MejorSolucion.OBJ){ System.out.println(); System.out.println("Mejora con OBJ= "+

mejora.mejorOBJ+" con sentido "+numMejora); } } } }

68

CAPÍTULO 3: MULTI-START

69

3.1 DESCRIPCIÓN DEL PROGRAMA

Se aprovechan objetos de los dos capítulos anteriores:

• Azar

• CotaSalbpE

• CotaTC

• Cronometro

• Datos

• Evaluación

• Listas

• MatrizPesos

• MejoraLocal

• MejorSolucion

• NextTarea

• Ristra

• Salida

Se reemplazan Principal y SolucionInicial para adaptarlos al funcionamiento del Multi-Start.

70

3.2 LISTADO DE OBJETOS

3.2.1 Principal

public class Principal { public static void main(String args[]) { String sentido; int numRistras; int subNum; Cronometro cr = new Cronometro(); cr.inicio(); //Puesta a cero del cronómetro Azar.semilla(); Datos datos = new Datos(args); datos.importaDatos(); Salida salida = new Salida(args[6]); SolucionInicial solini; MatrizPesos.inicializa(); CotaSalbpE cota = new CotaSalbpE(); MejorSolucion.inicializa(); MejoraLocal mejora; numRistras = 0; cr.fin(); for(int numIni=1; !MejorSolucion.optimo &&

cr.tiempo()<=(Integer.valueOf(args[4].trim()).intValue()); numIni++){

if((numIni%2)!=0) sentido = "ID"; else sentido = "DI"; MatrizPesos.actualizaPesoAzar(sentido); solini = new SolucionInicial(sentido); solini.creaSolucion(14); mejora = new MejoraLocal(solini.ristra, sentido); int numRis=Integer.valueOf(args[5].trim()).intValue(); subNum = mejora.inicia(numRis); numRistras += subNum; cr.fin(); } System.out.println(); System.out.println(); System.out.println("MEJOR SOLUCION"); System.out.println("OBJ= "+MejorSolucion.OBJ); System.out.println("N = "+MejorSolucion.N); System.out.println("TC = "+MejorSolucion.TC); cr.fin(); System.out.println(); System.out.println("Tiempo de ejecucion: "+cr.tiempo()+" s");

71

salida.tablaSalida(numRistras, cr.tiempo()); salida.estacionesSalida(); salida.escribeSalida(); } }

3.2.2 SolucionInicial

public class SolucionInicial { String sentido; int tareapos[]; Ristra ristra; NextTarea next; public SolucionInicial(String sentido) { this.sentido = sentido; } public void creaSolucion(int h) { tareapos = new int[2]; ristra = new Ristra(sentido); next = new NextTarea(sentido); for(int i=1; i<=Datos.NumTareas; i++){ tareapos = next.getTarea(h, ristra.ultimaT); ristra.actualizaRistraT(tareapos[0]); next.lista.actualizaListas(tareapos); } } }