Пример #1
0
  /**
   * Se verifica el canal tenga un enlace libre según la exclusividad buscada.
   *
   * @param exclusividad
   * @return
   */
  public boolean libreSegunExclusividad(Exclusividad exclusividad) {

    if (Exclusividad.Exclusivo == exclusividad) return tieneEnlacesExclusivos();

    if (Exclusividad.SinReservasBronce == exclusividad) {
      for (Enlace e : enlacesNecesarios) {
        if (!e.isBloqueado()) {
          boolean tieneReservasBronce = false;

          for (Servicio s : e.getReservas()) {
            if (s.getSolicitud().getNivel() == Nivel.Bronce) {
              tieneReservasBronce = true;
              break;
            }
          }
          if (!tieneReservasBronce) return true;
        }
      }
      return false;
    }

    /* Exclusividad : NoExclusivo (comentario aamadeo) */
    for (Enlace e : enlacesNecesarios) {
      if (!e.isBloqueado()) return true;
    }
    return false;
  }
Пример #2
0
  @Override
  public Individuo cruzar(Individuo i1, Individuo i2) {
    Solution s1 = (Solution) i1;
    Solution s2 = (Solution) i2;

    // System.out.println("---------------------------");
    // System.out.println("@Padre1@" + s1 + "@Padre1@.");
    // System.out.println("@Padre2@" + s2 + "@Padre2@.");

    Collection<Servicio> hijoAux = new ArrayList<Servicio>();
    Solution hijo = new Solution(3);

    List<Nodo> primeros = new ArrayList<Nodo>();
    List<Nodo> iguales = new ArrayList<Nodo>();

    Camino nuevoPrimario = null;
    Iterator<Servicio> iterador1 = s1.getGenes().iterator();
    Iterator<Servicio> iterador2 = s2.getGenes().iterator();

    Servicio gen1 = null;
    Servicio gen2 = null;
    // int i = 0;

    /*
     * Cálculos del Nuevo Camino Primario y del Nuevo Camino Secundario.
     */
    while (iterador1.hasNext() && iterador2.hasNext()) {

      // i++;
      // System.out.println("Generación: " + i);
      iguales.clear();
      primeros.clear();
      gen1 = iterador1.next();
      gen2 = iterador2.next();
      Camino primario1 = gen1.getPrimario();
      Camino primario2 = gen2.getPrimario();
      Nivel nivel = gen1.getSolicitud().getNivel();
      Exclusividad exclusividadPrimario = gen1.getSolicitud().getExclusividadPrimario();

      /*
       * P0. Se controla que los caminos principales existan. Si no
       * existen se retorna un servicio nulo y si solo no existe en uno,
       * se retorna el otro servicio padre.
       */
      if (primario1 == null && primario2 == null) {
        hijoAux.add(this.servicioNulo(gen1));
        continue;
      } else if (primario1 == null) {
        gen2.setPrimario();
        if (nivel != Nivel.Bronce) {
          gen2.setAlternativo();
        }
        hijoAux.add(gen2);
        continue;
      } else if (primario2 == null) {
        gen1.setPrimario();
        if (nivel != Nivel.Bronce) {
          gen1.setAlternativo();
        }
        hijoAux.add(gen1);
        continue;
      }

      Nodo nodo = primario1.getOrigen();
      primeros.add(nodo);
      iguales.add(nodo);
      /*
       * P1.1. Se obtienen los Nodos del primer padre.
       */
      for (Salto salto : primario1.getSaltos()) {
        nodo = salto.getCanal().getOtroExtremo(nodo);
        primeros.add(nodo);
      }

      nodo = primario2.getOrigen();

      /*
       * P1.2. Se copian los Nodos iguales entre los caminos de los
       * padres.
       */
      for (Salto salto : primario2.getSaltos()) {
        nodo = salto.getCanal().getOtroExtremo(nodo);
        if (primeros.contains(nodo)) {
          iguales.add(nodo);
        }
      }

      Nodo inicio = primario1.getOrigen();

      // se carga el nuevo Camino Primario.
      nuevoPrimario = new Camino(inicio);

      /*
       * P2.1. Para cada uno de los Nodos iguales se realiza dijkstra en
       * el orden en que fueron insertados. Si en el proceso el nodo
       * destino ya se encuenta en el camino creado, se continua al
       * siguiente nodo.
       */
      for (Nodo next : iguales) {

        // Se continua si ya existe en el camino creado.
        if (nuevoPrimario.contiene(next)) continue;

        // Camino subCamino = inicio.busquedaAnchura1Nivel(next,
        // exclusividadPrimario);

        // if (subCamino == null)
        Camino subCamino = inicio.dijkstra(next, exclusividadPrimario);

        // Condición que si es cierta, ocurrio un error
        if (subCamino == null) {
          nuevoPrimario.desbloquearCanales();
          nuevoPrimario = null;
          break;
          /*
           * Poblacion.getRed().drawServicio(gen1, dir,
           * "cruce_error_a"); Poblacion.getRed().drawServicio(gen2,
           * dir, "cruce_error_b");
           * Poblacion.getRed().utilizacion(dir, "");
           *
           * System.err.println("Generacion: " + i);
           * System.err.println("Desde " + inicio + " hasta " + next);
           * System.err.println(nuevoPrimario);
           *
           * System.err.println("Primeros:"); for (Nodo n : primeros)
           * System.err.print("" + n + "-");
           *
           * System.err.println("\nIguales:"); for (Nodo n1 : iguales)
           * System.err.print("" + n1 + "-");
           *
           * System.err.println(); for (Servicio s : hijoAux)
           * System.err.println("Servicio: " + s);
           *
           * System.exit(1);
           */
        }

        // se va anexando el camino creado.
        nuevoPrimario.anexar(subCamino);
        // luego de agregar, se bloquea los Canales.
        subCamino.bloquearCanales();
        inicio = next;
      }

      // Si no se encontro camino entonces se guarda un servicio null.
      if (nuevoPrimario == null) {
        hijoAux.add(this.servicioNulo(gen1));
        continue;
      }
      // Al finalizar el camino Primario se desbloquean los nodos.
      nuevoPrimario.desbloquearCanales();

      /*
       * P2.2. Se crea el nuevo Servicio y se asigna su Camino Primario.
       */
      Servicio newServicio = new Servicio(gen1.getSolicitud());
      newServicio.setPrimario(nuevoPrimario);
      newServicio.setPrimario();

      /*
       * P3.1. Cargar Nuevo Secundario: Realizar algoritmo Shortest Path
       * Disjktra (SPD) desde el Nodo inicio al Nodo fin.
       */
      if (nivel != Nivel.Bronce) {
        newServicio.buscarAlternativo();
        newServicio.setAlternativo();
      }
      /*
       * P3.2. Se almacena el Nuevo Servicio (gen), a un conjunto
       * auxiliar.
       */
      hijoAux.add(newServicio);
    }

    /*
     * P4.1. Se almacena el nuevo conjunto de Nuevos Servicios en el
     * Conjunto Hijo.
     */
    Collection<Servicio> aux = new TreeSet<Servicio>(hijoAux);
    hijo.setGenes(aux);

    // System.out.println(" #Hijo#" + hijo + "#Hijo.#");
    // System.out.println("---------------------------");

    return hijo;
  }
Пример #3
0
 /*
  * Funcion para obtener un servicio sin respuesta (Servicio Nulo)
  */
 private Servicio servicioNulo(Servicio gen1) {
   Servicio newServicio = new Servicio(gen1.getSolicitud());
   newServicio.setPrimario(null);
   newServicio.setAlternativo(null);
   return newServicio;
 }