public List<Integer> tour_selection(int depth) {
// selection based on utility
List<Integer> selected = new ArrayList<Integer>();
List<Integer> candidate = new ArrayList<Integer>();
for (int k = 0; k < problem_.getNumberOfObjectives(); k++) {
selected.add(
k); // WARNING! HERE YOU HAVE TO USE THE WEIGHT PROVIDED BY QINGFU (NOT SORTED!!!!)
}
for (int n = problem_.getNumberOfObjectives(); n < populationSize; n++) {
candidate.add(n); // set of unselected weights
}
while (selected.size() < (int) (populationSize / 5.0)) {
// int best_idd = (int) (rnd_uni(&rnd_uni_init)*candidate.size()), i2;
int best_idd = (int) (PseudoRandom.randDouble() * candidate.size());
// System.out.println(best_idd);
int i2;
int best_sub = candidate.get(best_idd);
int s2;
for (int i = 1; i < depth; i++) {
i2 = (int) (PseudoRandom.randDouble() * candidate.size());
s2 = candidate.get(i2);
// System.out.println("Candidate: "+i2);
if (utility_[s2] > utility_[best_sub]) {
best_idd = i2;
best_sub = s2;
}
}
selected.add(best_sub);
candidate.remove(best_idd);
}
return selected;
}
@Override
public void executeMethod() throws JMException {
int[] permutation = new int[populationSize];
Utils.randomPermutation(permutation, populationSize);
List<Integer> order = tour_selection(10);
for (int i = 0; i < order.size(); i++) {
// int n = permutation[i]; // or int n = i;
int n = order.get(i); // or int n = i;
frequency_[n]++;
int type;
double rnd = PseudoRandom.randDouble();
// STEP 2.1. Mating selection based on probability
if (rnd < delta_) // if (rnd < realb)
{
type = 1; // neighborhood
} else {
type = 2; // whole population
}
Vector<Integer> p = new Vector<Integer>();
matingSelection(p, n, 1, type);
// STEP 2.2. Reproduction
Solution[] parents = new Solution[2];
parents[0] = population.get(p.get(0));
parents[1] = population.get(n);
Solution[] offSpring = (Solution[]) crossoverOperator.execute(parents, (CITO_CAITO) problem_);
mutationOperator.execute(offSpring[0], (CITO_CAITO) problem_);
// mutationOperator.execute(offSpring[1], problem_);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
// problem_.evaluate(offSpring[1]);
// problem_.evaluateConstraints(offSpring[1]);
evaluations++;
// STEP 2.3. Repair. Not necessary
// STEP 2.4. Update z_
updateReference(offSpring[0]);
// updateReference(offSpring[1]);
// STEP 2.5. Update of solutions
updateProblem(offSpring[0], n, type);
// updateProblem(offSpring[1], n, type);
} // for
gen++;
if (gen % 30 == 0) {
comp_utility();
}
}
/**
* Gets 'size' elements from a population of more than 'size' elements using for this de
* enviromentalSelection truncation
*
* @param size The number of elements to get.
*/
public SolutionSet environmentalSelection(int size) {
if (solutionSet_.size() < size) {
size = solutionSet_.size();
}
// Create a new auxiliar population for no alter the original population
SolutionSet aux = new SolutionSet(solutionSet_.size());
int i = 0;
while (i < solutionSet_.size()) {
if (solutionSet_.get(i).getFitness() < 1.0) {
aux.add(solutionSet_.get(i));
solutionSet_.remove(i);
} else {
i++;
} // if
} // while
if (aux.size() < size) {
Comparator comparator = new FitnessComparator();
solutionSet_.sort(comparator);
int remain = size - aux.size();
for (i = 0; i < remain; i++) {
aux.add(solutionSet_.get(i));
}
return aux;
} else if (aux.size() == size) {
return aux;
}
double[][] distance = distance_.distanceMatrix(aux);
List<List<DistanceNode>> distanceList = new LinkedList<List<DistanceNode>>();
for (int pos = 0; pos < aux.size(); pos++) {
aux.get(pos).setLocation(pos);
List<DistanceNode> distanceNodeList = new ArrayList<DistanceNode>();
for (int ref = 0; ref < aux.size(); ref++) {
if (pos != ref) {
distanceNodeList.add(new DistanceNode(distance[pos][ref], ref));
} // if
} // for
distanceList.add(distanceNodeList);
} // for
for (int q = 0; q < distanceList.size(); q++) {
Collections.sort(distanceList.get(q), distanceNodeComparator);
} // for
while (aux.size() > size) {
double minDistance = Double.MAX_VALUE;
int toRemove = 0;
i = 0;
Iterator<List<DistanceNode>> iterator = distanceList.iterator();
while (iterator.hasNext()) {
List<DistanceNode> dn = iterator.next();
if (dn.get(0).getDistance() < minDistance) {
toRemove = i;
minDistance = dn.get(0).getDistance();
// i y toRemove have the same distance to the first solution
} else if (dn.get(0).getDistance() == minDistance) {
int k = 0;
while ((dn.get(k).getDistance() == distanceList.get(toRemove).get(k).getDistance())
&& k < (distanceList.get(i).size() - 1)) {
k++;
}
if (dn.get(k).getDistance() < distanceList.get(toRemove).get(k).getDistance()) {
toRemove = i;
} // if
} // if
i++;
} // while
int tmp = aux.get(toRemove).getLocation();
aux.remove(toRemove);
distanceList.remove(toRemove);
Iterator<List<DistanceNode>> externIterator = distanceList.iterator();
while (externIterator.hasNext()) {
Iterator<DistanceNode> interIterator = externIterator.next().iterator();
while (interIterator.hasNext()) {
if (interIterator.next().getReference() == tmp) {
interIterator.remove();
continue;
} // if
} // while
} // while
} // while
return aux;
} // environmentalSelection
/**
* @author Juanjo This method selects N solutions from a set M, where N <= M using the same method
* proposed by Qingfu Zhang, W. Liu, and Hui Li in the paper describing MOEA/D-DRA (CEC 09
* COMPTETITION) An example is giving in that paper for two objectives. If N = 100, then the
* best solutions attenting to the weights (0,1), (1/99,98/99), ...,(98/99,1/99), (1,0) are
* selected.
* <p>Using this method result in 101 solutions instead of 100. We will just compute 100 even
* distributed weights and used them. The result is the same
* <p>In case of more than two objectives the procedure is: 1- Select a solution at random 2-
* Select the solution from the population which have maximum distance to it (whithout
* considering the already included)
* @param n: The number of solutions to return
* @return A solution set containing those elements
*/
SolutionSet finalSelection(int n) throws JMException {
SolutionSet res = new SolutionSet(n);
if (problem_.getNumberOfObjectives() == 2) { // subcase 1
double[][] intern_lambda = new double[n][2];
for (int i = 0; i < n; i++) {
double a = 1.0 * i / (n - 1);
intern_lambda[i][0] = a;
intern_lambda[i][1] = 1 - a;
} // for
// we have now the weights, now select the best solution for each of them
for (int i = 0; i < n; i++) {
Solution current_best = population.get(0);
int index = 0;
double value = fitnessFunction(current_best, intern_lambda[i]);
for (int j = 1; j < n; j++) {
double aux =
fitnessFunction(
population.get(j), intern_lambda[i]); // we are looking the best for the weight i
if (aux < value) { // solution in position j is better!
value = aux;
current_best = population.get(j);
}
}
res.add(new Solution(current_best));
}
} else { // general case (more than two objectives)
Distance distance_utility = new Distance();
int random_index = PseudoRandom.randInt(0, population.size() - 1);
// create a list containing all the solutions but the selected one (only references to them)
List<Solution> candidate = new LinkedList<Solution>();
candidate.add(population.get(random_index));
for (int i = 0; i < population.size(); i++) {
if (i != random_index) {
candidate.add(population.get(i));
}
} // for
while (res.size() < n) {
int index = 0;
Solution selected = candidate.get(0); // it should be a next! (n <= population size!)
double distance_value =
distance_utility.distanceToSolutionSetInObjectiveSpace(selected, res);
int i = 1;
while (i < candidate.size()) {
Solution next_candidate = candidate.get(i);
double aux =
distance_value =
distance_utility.distanceToSolutionSetInObjectiveSpace(next_candidate, res);
if (aux > distance_value) {
distance_value = aux;
index = i;
}
i++;
}
// add the selected to res and remove from candidate list
res.add(new Solution(candidate.remove(index)));
} //
}
return res;
}