Beispiel #1
0
 @Override
 public Iterator<Move> createRandomMoveIterator(
     ScoreDirector scoreDirector, Random workingRandom) {
   CheapTimeSolution cheapTimeSolution = (CheapTimeSolution) scoreDirector.getWorkingSolution();
   Map<Machine, List<TaskAssignment>> positivePillarMap =
       new LinkedHashMap<Machine, List<TaskAssignment>>(
           cheapTimeSolution.getGlobalPeriodRangeTo());
   Map<Machine, List<TaskAssignment>> negativePillarMap =
       new LinkedHashMap<Machine, List<TaskAssignment>>(
           cheapTimeSolution.getGlobalPeriodRangeTo());
   List<TaskAssignment> taskAssignmentList = cheapTimeSolution.getTaskAssignmentList();
   int pillarCapacity =
       (taskAssignmentList.size() * 2 / cheapTimeSolution.getMachineList().size()) + 1;
   for (TaskAssignment taskAssignment : taskAssignmentList) {
     Machine machine = taskAssignment.getMachine();
     Task task = taskAssignment.getTask();
     Integer startPeriod = taskAssignment.getStartPeriod();
     if (startPeriod != null) {
       if (startPeriod < task.getStartPeriodRangeTo() - 1) {
         List<TaskAssignment> pillar = positivePillarMap.get(machine);
         if (pillar == null) {
           pillar = new ArrayList<TaskAssignment>(pillarCapacity);
           positivePillarMap.put(machine, pillar);
         }
         pillar.add(taskAssignment);
       }
       if (startPeriod > task.getStartPeriodRangeFrom()) {
         List<TaskAssignment> pillar = negativePillarMap.get(machine);
         if (pillar == null) {
           pillar = new ArrayList<TaskAssignment>(pillarCapacity);
           negativePillarMap.put(machine, pillar);
         }
         pillar.add(taskAssignment);
       }
     }
   }
   List<List<TaskAssignment>> positivePillarList =
       new ArrayList<List<TaskAssignment>>(positivePillarMap.size());
   for (List<TaskAssignment> pillar : positivePillarMap.values()) {
     if (pillar.size() > 1) {
       positivePillarList.add(pillar);
     }
   }
   List<List<TaskAssignment>> negativePillarList =
       new ArrayList<List<TaskAssignment>>(negativePillarMap.size());
   for (List<TaskAssignment> pillar : negativePillarMap.values()) {
     if (pillar.size() > 1) {
       negativePillarList.add(pillar);
     }
   }
   return new RandomCheapTimePillarSlideMoveIterator(
       positivePillarList, negativePillarList, workingRandom);
 }
Beispiel #2
0
 public Move next() {
   int listIndex = workingRandom.nextInt(totalSize);
   boolean positive = listIndex < positivePillarList.size();
   List<TaskAssignment> basePillar =
       positive
           ? positivePillarList.get(listIndex)
           : negativePillarList.get(listIndex - positivePillarList.size());
   int basePillarSize = basePillar.size();
   int subPillarSize = workingRandom.nextInt(basePillarSize);
   // Random sampling: See http://eyalsch.wordpress.com/2010/04/01/random-sample/
   // Used Swapping instead of Floyd because subPillarSize is large, to avoid hashCode() hit
   TaskAssignment[] sandboxPillar =
       basePillar.toArray(
           new TaskAssignment[basePillar.size()]); // Clone to avoid changing basePillar
   List<TaskAssignment> subPillar = new ArrayList<TaskAssignment>(subPillarSize);
   int minimumAbsDiff = Integer.MAX_VALUE;
   for (int i = 0; i < subPillarSize; i++) {
     int index = i + workingRandom.nextInt(basePillarSize - i);
     TaskAssignment taskAssignment = sandboxPillar[index];
     Task task = taskAssignment.getTask();
     int absDiff =
         positive
             ? task.getStartPeriodRangeTo() - 1 - taskAssignment.getStartPeriod()
             : taskAssignment.getStartPeriod() - task.getStartPeriodRangeFrom();
     if (absDiff < minimumAbsDiff) {
       minimumAbsDiff = absDiff;
     }
     subPillar.add(taskAssignment);
     sandboxPillar[index] = sandboxPillar[i];
   }
   int startPeriodDiff = 1 + workingRandom.nextInt(minimumAbsDiff);
   if (!positive) {
     startPeriodDiff = -startPeriodDiff;
   }
   return new CheapTimePillarSlideMove(subPillar, startPeriodDiff);
 }