Erreur introuvable :/

Résolu

asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention -
asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention - 24 oct. 2012 à 18:56

Bonsoir , jai toujours cette erreur:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
[java] at jadex.examples.cleanerworld.multi.testenvironment.ga.ModifiedNSGAII.execute(Unknown Source)

le souci que jarrive pas de tt a localisé l'erreur depuis 3 jours , qui peut maider?
voiçi ma classe:
//=================================================================================================================
// My adapted version of cleaner agent
// (Modified version of r-NSGAII)
//=================================================================================================================

package jadex.examples.cleanerworld.multi.testenvironment.ga;

import jadex.examples.cleanerworld.multi.Obstacle;
import jadex.examples.cleanerworld.multi.TestCase;
import jadex.examples.cleanerworld.multi.Waste;
import jadex.examples.cleanerworld.multi.testenvironment.export.TestCase2XML;
import jadex.examples.cleanerworld.multi.utils.CommonUtil;
import jadex.examples.cleanerworld.multi.mocks.MockWasteObsRealProblem;
import jadex.examples.cleanerworld.multi.testenvironment.ga.rdominance;
import jadex.examples.cleanerworld.multi.testenvironment.ga.RefPoint;

import java.io.File;

import jmetal.base.*;
import jmetal.util.*;

public class ModifiedNSGAII extends Algorithm {

private Problem problem_;

public ModifiedNSGAII(Problem problem){
this.problem_ = problem;
} // NSGAII

public SolutionSet execute() throws JMException {
int populationSize ;
int maxEvaluations ;
int evaluations ;
int numWaste =4;
int numObstacles =4;
double dmin = 0,dmax = 0;
double [][]chromosomes = new double[1000][1000];
double fmin[]=new double[7];//7 is the number of obj
double fmax[]= new double [7];
double fit0[]= new double[1000];
double fit1[]= new double[1000];
double fit2[]= new double[1000];
double fit3[]= new double[1000];
double fit4[]= new double[1000];
double fit5[]= new double[1000];
double fit6[]= new double[1000];
double sigma= 1;
double sigma_2 = 1;
int m=0;
int w=0;
// les c

SolutionSet population ;
SolutionSet offspringPopulation ;
SolutionSet union ;

Operator mutationOperator ;
Operator crossoverOperator ;
Operator selectionOperator ;

Distance distance = new Distance() ;

//======================
//Read the parameters
//======================
populationSize = ((Integer)this.getInputParameter("populationSize")).intValue();
maxEvaluations = ((Integer)this.getInputParameter("maxEvaluations")).intValue();

//======================
//Initialize the variables
//======================
population = new SolutionSet(populationSize);
evaluations = 0;
RefPoint R = new RefPoint(0.5,0.6);
//======================
//Read the operators
//======================
mutationOperator = this.operators_.get("mutation");
crossoverOperator = this.operators_.get("crossover");
selectionOperator = this.operators_.get("selection");

//=====================================================
//1--Create the initial solutionSet and assign fitness
//======================================================
Solution newSolution;
MockWasteObsRealProblem problem_ = new MockWasteObsRealProblem(numWaste, numObstacles);
String pathPrefix = CommonUtil.getProjectPath() + File.separatorChar + "inputs" + File.separatorChar;
int d1=0;

for (int i = 0; i < populationSize; i++) {

newSolution = new Solution(problem_);
String fullPath = pathPrefix + "tc" + String.valueOf(i+1) + ".xml";
loadPredefiedTestCase(newSolution, fullPath);
problem_.evaluate(newSolution);
problem_.evaluateConstraints(newSolution);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations++;
// System.out.println("============evaluations n° = "+ evaluations+"========================");
population.add(newSolution);
} //for

//*******************************************************************
// -- Start the evolution process --
//********************************************************************

// Generations ...
while (evaluations < maxEvaluations) { //Begin while
w++;
System.out.println("==========================generation=================="+w);
offspringPopulation = new SolutionSet(populationSize);
Solution [] parents = new Solution[2];
for (int i = 0; i < (populationSize/2); i++){
System.out.println("i dans la generation = "+i);

//=================================
//2 - Select parents for reproduction
//===================================
parents[0] = (Solution)selectionOperator.execute(population);
parents[1] = (Solution)selectionOperator.execute(population);

if (evaluations < maxEvaluations) { //We add offSprings to offSpringPopulation
//=================================================
//3 - Perform crossover and mutation to obtain offspring
//==================================================

Solution [] offSpring = (Solution []) crossoverOperator.execute(parents);
mutationOperator.execute(offSpring[0]);
mutationOperator.execute(offSpring[1]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
problem_.evaluate(offSpring[1]);
problem_.evaluateConstraints(offSpring[1]);
//================================================
//3+1 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(offSpring[0]);

for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;

offspringPopulation.add(offSpring[1]);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations += 2;
// System.out.println("============evaluations = "+ evaluations+"========================");

}
else { //We add Parents to offSpringPopulation
//================================================
//3+2 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(new Solution(parents[0]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
offspringPopulation.add(new Solution(parents[1]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
} // if
} // for

//=================================================================
//4 -- Create the solutionSet Union = Initial solutionSet + offSpring
//=================================================================
union = ((SolutionSet)population).union(offspringPopulation);

System.out.println("affichage de l'union de taille = "+union.size());
for(int i=0;i<union.size();i++)
{
for(int j=(((numWaste+numObstacles)*2));j<=(((numWaste+numObstacles)*2)+6);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}

//==============================================================================
//5 -- Compute the fmin and fmax for each objective functions of the Union SolutionSet
//==============================================================================
for(int i=0;i< (union.size());i++)
{
fit0[i]=problem_.getf0(i);
fit1[i]=problem_.getf1(i);
fit2[i]=problem_.getf2(i);
fit3[i]=problem_.getf3(i);
fit4[i]=problem_.getf4(i);
fit5[i]=problem_.getf5(i);
fit6[i]=problem_.getf6(i);

}
System.out.println("affichage de fit0");

System.out.println("\n");
fmin[m]=fit0[0];
fmax[m]=fit0[0];
//f0//
for(int i=0;i<=(union.size()-2);i++)
{
if(fit0[i+1]<fmin[m])
{
fmin[m]=fit0[i+1];
}
if(fit0[i+1]> fmax[m])
{
fmax[m]=fit0[i+1];
}
}

m++;
//f1//
fmin[m]=fit1[0];
fmax[m]=fit1[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit1[i+1]<fmin[m])
{
fmin[m]=fit1[i+1];
}
if(fit1[i+1]> fmax[m])
{
fmax[m]=fit1[i+1];
}
}

m++;
//f2//
fmin[m]=fit2[0];
fmax[m]=fit2[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit2[i+1]<fmin[m])
{
fmin[m]=fit2[i+1];
}
if(fit2[i+1]> fmax[m])
{
fmax[m]=fit2[i+1];
}
}

m++;
//f3//
fmin[m]=fit3[0];
fmax[m]=fit3[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit3[i+1]<fmin[m])
{
fmin[m]=fit3[i+1];
}
if(fit3[i+1]> fmax[m])
{
fmax[m]=fit3[i+1];
}
}

m++;
//f4//
fmin[m]=fit4[0];
fmax[m]=fit4[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit4[i+1]<fmin[m])
{
fmin[m]=fit4[i+1];
}
if(fit4[i+1]> fmax[m])
{
fmax[m]=fit4[i+1];
}
}

m++;
//f5//
fmin[m]=fit5[0];
fmax[m]=fit5[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit5[i+1]<fmin[0])
{
fmin[m]=fit5[i+1];
}
if(fit5[i+1]> fmax[m])
{
fmax[m]=fit5[i+1];
}
}

m++;
//f6//
fmin[m]=fit6[0];
fmax[m]=fit6[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit6[i+1]<fmin[m])
{
fmin[m]=fit6[i+1];
}
if(fit6[i+1]> fmax[m])
{
fmax[m]=fit6[i+1];
}
}

//=============================================================================================
//6 -- Sort based on r_dominance
//=============================================================================================

sigma_2= sigma_2 - ((1-sigma)/w);
System.out.println("sigma_2 = "+sigma_2);

//============================================================================
// 6-1 Compute the distance to reference assignement(X) for the union SolutionSet
//=============================================================================

int SizeUnion = union.size();
distance_to_reference_assignement(numWaste,numObstacles,chromosomes,7,SizeUnion,fmin,fmax,R);
/*System.out.println("affichage de t aprés le calcul de distance de references = ");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste+numObstacles)*2+7);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/
/*Compute the min and max of X**/
dmin= chromosomes[0][(numWaste+numObstacles)*2+7];
dmax=chromosomes[0][(numWaste+numObstacles)*2+7];
for(int i=0;i<=(union.size()-2);i++)
{
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] < dmin)
{
dmin=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] > dmax)
{
dmax=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
}

System.out.println("dmin = "+dmin);
System.out.println("dmax = "+dmax);
//======================================================
//6-2 non_domination_sort_mod of the Union SolutionSet
//=======================================================

rdominance ranking = new rdominance(union,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);

int remain = populationSize;
int index = 0;
SolutionSet front = null;
population.clear();

/* System.out.println("affichage de l'union avec le rank =");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste +numObstacles)*2+8);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/

// Obtain the next front
front = ranking.getSubfront(index);

while ((remain > 0) && (remain >= front.size())){
//Assign crowding distance to individuals
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
//Add the individuals of this front
for (int k = 0; k < front.size(); k++ ) {
population.add(front.get(k));
} // for

//Decrement remain
remain = remain - front.size();

//Obtain the next front
index++;
if (remain > 0) {
front = ranking.getSubfront(index);
} // if
// y++;
} // while

// remain is less than front(index).size, insert only the best one
if (remain > 0) { // front contains individuals to insert
distance.crowdingDistanceAssignment(front,problem_.getNumberOfObjectives());
front.sort(new jmetal.base.operator.comparator.CrowdingComparator());
for (int k = 0; k < remain; k++) {
population.add(front.get(k));
} // for

remain = 0;
} // if
} // while

// Return the first non-dominated front
rdominance ranking = new rdominance(population,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);
return ranking.getSubfront(0);
} // execute

//*************************************************************************************************************
// Load predefined a test case from xml file
//**************************************************************************************************************
private void loadPredefiedTestCase(Solution s, String fileFullPath) {
File f = new File(fileFullPath);
if (f.exists()) {
TestCase tc = TestCase2XML.load(fileFullPath);

DecisionVariables decisionVariables = s.getDecisionVariables();
int mid = decisionVariables.size() / 2;
int numObstacles = tc.getObstacles().length;
int numWaste = tc.getWastes().length;

if (numObstacles + numWaste != mid) {
CommonUtil.print("ModifiedNSGAII: the numbers of obstacle and waste are not compatible!");
} else {
try {
for (int i = 0; i < numObstacles; i++) {
Obstacle obs = tc.getObstacle(i);
decisionVariables.variables_[i].setValue(obs.getLocation().getX());
decisionVariables.variables_[i+mid].setValue(obs.getLocation().getY());

}

for (int i = 0; i < numWaste; i++) {
Waste w = tc.getWaste(i);
decisionVariables.variables_[numObstacles + i].setValue(w.getLocation().getX());
decisionVariables.variables_[numObstacles + i +mid].setValue(w.getLocation().getY());
}

} catch (JMException e) {
e.printStackTrace();
}
}

} else {
CommonUtil.print("ModifiedNSGAII: file " + fileFullPath + " does not exist!");
}
}
//*************************************************************************************************************
// Distance_to_reference_assignement function
//*************************************************************************************************************
public static double distance_to_reference_assignement(int numWaste,int numObstacles,double[][] chromosomes,int M,int SizeUnion,double[] fmin,double[] fmax,RefPoint R)
{
double x = 0;
for(int j=0;j<SizeUnion;j++)
{
//System.out.println("j = "+j);
double result;
double sum = 0;

for (int i1=0;i1<M;i1++)
{
//System.out.println("M = "+i1);
if(i1 % 2 == 0)
{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.x) / (fmax[i1]-fmin[i1]));
sum= sum +floor(B/7,4);

}else{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.y) / (fmax[i1]-fmin[i1]));
sum = sum + floor(B/7,4);

}
}

result=Math.sqrt(sum);
x=floor(result,4);
chromosomes[j][((numWaste+numObstacles)*2)+7]=x;

}
return x;
}
//===============================================================
public static double floor(double a, int n) {
double p = Math.pow(10.0, n);
return Math.floor((a*p)+0.5) / p;
}
//=========================================================

public static double carre(double x)
{
double y = x * x;
return y;
}

} // NSGA-II

//===========================================================================================================
//By Sabrine Kalboussi,Master student,ISG of Tunis
//===========================================================================================================

A voir également:

Erreur introuvable :/
Supprimer fichier introuvable - Guide
Erreur 0x80070643 - Accueil - Windows
Erreur 0x80070643 Windows 10 : comment résoudre le problème de la mise à jour KB5001716 - Accueil - Windows
J'aime par erreur facebook notification - Forum Facebook
Java code erreur 1603 ✓ - Forum Windows

5 réponses

Réponse 1 / 5

L0ci Messages postés 110 Date d'inscription Statut Membre Dernière intervention 30

Bonjour,

J'ai pas lu tout le code, cependant, cette erreur signifie que tu accèdes à un élément inexistant d'un tableau.
Je m'explique :

   int[] tableau = new int[10]; 
   tableau[9];  //ok 
   tableau[10]; //IndexOutOfBoundsException. ici j'essaie d'accéder au 11ème élément d'un tableau qui n'en a que 10.

Il faut donc vérifier tes boucles et les accès dynamiques à tes tableaux.

asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention

merci pour votre réponse :)
oui je sais la signification d'erreur mais j'ai tout vérifié déjà :/ j'arrive pas a trouver l'erreur.
s'il vous plait, je fais mettre la classe encore une fois en mettant en GRAS les boucles, vérifiez avec moi. :(
je serai énormément remercientes

L0ci Messages postés 110 Date d'inscription Statut Membre Dernière intervention 30

Je suis pas spécialiste java, mais y'a pas moyen d'exécuter en pas à pas, histoire de trouver quelle ligne et les valeurs des différentes variables au moment du bug?

Réponse 2 / 5

asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention

package jadex.examples.cleanerworld.multi.testenvironment.ga;

import jadex.examples.cleanerworld.multi.Obstacle;
import jadex.examples.cleanerworld.multi.TestCase;
import jadex.examples.cleanerworld.multi.Waste;
import jadex.examples.cleanerworld.multi.testenvironment.export.TestCase2XML;
import jadex.examples.cleanerworld.multi.utils.CommonUtil;
import jadex.examples.cleanerworld.multi.mocks.MockWasteObsRealProblem;
import jadex.examples.cleanerworld.multi.testenvironment.ga.rdominance;
import jadex.examples.cleanerworld.multi.testenvironment.ga.RefPoint;

import java.io.File;

import jmetal.base.*;
import jmetal.util.*;

public class ModifiedNSGAII extends Algorithm {

private Problem problem_;

public ModifiedNSGAII(Problem problem){
this.problem_ = problem;
} // NSGAII

public SolutionSet execute() throws JMException {
int populationSize ;
int maxEvaluations ;
int evaluations ;
int numWaste =4;
int numObstacles =4;
double dmin = 0,dmax = 0;
double [][]chromosomes = new double[1000][1000];
double fmin[]=new double[7];//7 is the number of obj
double fmax[]= new double [7];
double fit0[]= new double[1000];
double fit1[]= new double[1000];
double fit2[]= new double[1000];
double fit3[]= new double[1000];
double fit4[]= new double[1000];
double fit5[]= new double[1000];
double fit6[]= new double[1000];
double sigma= 1;
double sigma_2 = 1;
int m=0;
int w=0;
// les c

SolutionSet population ;
SolutionSet offspringPopulation ;
SolutionSet union ;

Operator mutationOperator ;
Operator crossoverOperator ;
Operator selectionOperator ;

Distance distance = new Distance() ;

//======================
//Read the parameters
//======================
populationSize = ((Integer)this.getInputParameter("populationSize")).intValue();
maxEvaluations = ((Integer)this.getInputParameter("maxEvaluations")).intValue();

//======================
//Initialize the variables
//======================
population = new SolutionSet(populationSize);
evaluations = 0;
RefPoint R = new RefPoint(0.5,0.6);
//======================
//Read the operators
//======================
mutationOperator = this.operators_.get("mutation");
crossoverOperator = this.operators_.get("crossover");
selectionOperator = this.operators_.get("selection");

//=====================================================
//1--Create the initial solutionSet and assign fitness
//======================================================
Solution newSolution;
MockWasteObsRealProblem problem_ = new MockWasteObsRealProblem(numWaste, numObstacles);
String pathPrefix = CommonUtil.getProjectPath() + File.separatorChar + "inputs" + File.separatorChar;
int d1=0;

for (int i = 0; i < populationSize; i++) {

newSolution = new Solution(problem_);
String fullPath = pathPrefix + "tc" + String.valueOf(i+1) + ".xml";
loadPredefiedTestCase(newSolution, fullPath);
problem_.evaluate(newSolution);
problem_.evaluateConstraints(newSolution);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations++;
// System.out.println("============evaluations n° = "+ evaluations+"========================");
population.add(newSolution);
} //for

//*******************************************************************
// -- Start the evolution process --
//********************************************************************

// Generations ...
while (evaluations < maxEvaluations) { //Begin while
w++;
System.out.println("==========================generation=================="+w);
offspringPopulation = new SolutionSet(populationSize);
Solution [] parents = new Solution[2];
for (int i = 0; i < (populationSize/2); i++){
System.out.println("i dans la generation = "+i);

//=================================
//2 - Select parents for reproduction
//===================================
parents[0] = (Solution)selectionOperator.execute(population);
parents[1] = (Solution)selectionOperator.execute(population);

if (evaluations < maxEvaluations) { //We add offSprings to offSpringPopulation
//=================================================
//3 - Perform crossover and mutation to obtain offspring
//==================================================

Solution [] offSpring = (Solution []) crossoverOperator.execute(parents);
mutationOperator.execute(offSpring[0]);
mutationOperator.execute(offSpring[1]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
problem_.evaluate(offSpring[1]);
problem_.evaluateConstraints(offSpring[1]);
//================================================
//3+1 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(offSpring[0]);

for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;

offspringPopulation.add(offSpring[1]);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations += 2;
// System.out.println("============evaluations = "+ evaluations+"========================");

}
else { //We add Parents to offSpringPopulation
//================================================
//3+2 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(new Solution(parents[0]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
offspringPopulation.add(new Solution(parents[1]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
} // if
} // for

//=================================================================
//4 -- Create the solutionSet Union = Initial solutionSet + offSpring
//=================================================================
union = ((SolutionSet)population).union(offspringPopulation);

System.out.println("affichage de l'union de taille = "+union.size());
for(int i=0;i<union.size();i++)
{
for(int j=(((numWaste+numObstacles)*2));j<=(((numWaste+numObstacles)*2)+6);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}

//==============================================================================
//5 -- Compute the fmin and fmax for each objective functions of the Union SolutionSet
//==============================================================================
for(int i=0;i< (union.size());i++)
{
fit0[i]=problem_.getf0(i);
fit1[i]=problem_.getf1(i);
fit2[i]=problem_.getf2(i);
fit3[i]=problem_.getf3(i);
fit4[i]=problem_.getf4(i);
fit5[i]=problem_.getf5(i);
fit6[i]=problem_.getf6(i);

}
System.out.println("affichage de fit0");

System.out.println("\n");
fmin[m]=fit0[0];
fmax[m]=fit0[0];
//f0//
for(int i=0;i<=(union.size()-2);i++)
{
if(fit0[i+1]<fmin[m])
{
fmin[m]=fit0[i+1];
}
if(fit0[i+1]> fmax[m])
{
fmax[m]=fit0[i+1];
}
}

m++;
//f1//
fmin[m]=fit1[0];
fmax[m]=fit1[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit1[i+1]<fmin[m])
{
fmin[m]=fit1[i+1];
}
if(fit1[i+1]> fmax[m])
{
fmax[m]=fit1[i+1];
}
}

m++;
//f2//
fmin[m]=fit2[0];
fmax[m]=fit2[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit2[i+1]<fmin[m])
{
fmin[m]=fit2[i+1];
}
if(fit2[i+1]> fmax[m])
{
fmax[m]=fit2[i+1];
}
}

m++;
//f3//
fmin[m]=fit3[0];
fmax[m]=fit3[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit3[i+1]<fmin[m])
{
fmin[m]=fit3[i+1];
}
if(fit3[i+1]> fmax[m])
{
fmax[m]=fit3[i+1];
}
}

m++;
//f4//
fmin[m]=fit4[0];
fmax[m]=fit4[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit4[i+1]<fmin[m])
{
fmin[m]=fit4[i+1];
}
if(fit4[i+1]> fmax[m])
{
fmax[m]=fit4[i+1];
}
}

m++;
//f5//
fmin[m]=fit5[0];
fmax[m]=fit5[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit5[i+1]<fmin[0])
{
fmin[m]=fit5[i+1];
}
if(fit5[i+1]> fmax[m])
{
fmax[m]=fit5[i+1];
}
}

m++;
//f6//
fmin[m]=fit6[0];
fmax[m]=fit6[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit6[i+1]<fmin[m])
{
fmin[m]=fit6[i+1];
}
if(fit6[i+1]> fmax[m])
{
fmax[m]=fit6[i+1];
}
}

//=============================================================================================
//6 -- Sort based on r_dominance
//=============================================================================================

sigma_2= sigma_2 - ((1-sigma)/w);
System.out.println("sigma_2 = "+sigma_2);

//============================================================================
// 6-1 Compute the distance to reference assignement(X) for the union SolutionSet
//=============================================================================

int SizeUnion = union.size();
distance_to_reference_assignement(numWaste,numObstacles,chromosomes,7,SizeUnion,fmin,fmax,R);
/*System.out.println("affichage de t aprés le calcul de distance de references = ");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste+numObstacles)*2+7);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/
/*Compute the min and max of X**/
dmin= chromosomes[0][(numWaste+numObstacles)*2+7];
dmax=chromosomes[0][(numWaste+numObstacles)*2+7];
for(int i=0;i<=(union.size()-2);i++)
{
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] < dmin)
{
dmin=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] > dmax)
{
dmax=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
}

System.out.println("dmin = "+dmin);
System.out.println("dmax = "+dmax);
//======================================================
//6-2 non_domination_sort_mod of the Union SolutionSet
//=======================================================

rdominance ranking = new rdominance(union,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);

int remain = populationSize;
int index = 0;
SolutionSet front = null;
population.clear();

/* System.out.println("affichage de l'union avec le rank =");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste +numObstacles)*2+8);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/

// Obtain the next front
front = ranking.getSubfront(index);

while ((remain > 0) && (remain >= front.size())){
//Assign crowding distance to individuals
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
//Add the individuals of this front
for (int k = 0; k < front.size(); k++ ) {
population.add(front.get(k));
} // for

//Decrement remain
remain = remain - front.size();

//Obtain the next front
index++;
if (remain > 0) {
front = ranking.getSubfront(index);
} // if
// y++;
} // while

// remain is less than front(index).size, insert only the best one
if (remain > 0) { // front contains individuals to insert
distance.crowdingDistanceAssignment(front,problem_.getNumberOfObjectives());
front.sort(new jmetal.base.operator.comparator.CrowdingComparator());
for (int k = 0; k < remain; k++) {
population.add(front.get(k));
} // for

remain = 0;
} // if
} // while

// Return the first non-dominated front
rdominance ranking = new rdominance(population,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);
return ranking.getSubfront(0);
} // execute

//*************************************************************************************************************
// Load predefined a test case from xml file
//**************************************************************************************************************
private void loadPredefiedTestCase(Solution s, String fileFullPath) {
File f = new File(fileFullPath);
if (f.exists()) {
TestCase tc = TestCase2XML.load(fileFullPath);

DecisionVariables decisionVariables = s.getDecisionVariables();
int mid = decisionVariables.size() / 2;
int numObstacles = tc.getObstacles().length;
int numWaste = tc.getWastes().length;

if (numObstacles + numWaste != mid) {
CommonUtil.print("ModifiedNSGAII: the numbers of obstacle and waste are not compatible!");
} else {
try {
for (int i = 0; i < numObstacles; i++) {
Obstacle obs = tc.getObstacle(i);
decisionVariables.variables_[i].setValue(obs.getLocation().getX());
decisionVariables.variables_[i+mid].setValue(obs.getLocation().getY());

}

for (int i = 0; i < numWaste; i++) {
Waste w = tc.getWaste(i);
decisionVariables.variables_[numObstacles + i].setValue(w.getLocation().getX());
decisionVariables.variables_[numObstacles + i +mid].setValue(w.getLocation().getY());
}

} catch (JMException e) {
e.printStackTrace();
}
}

} else {
CommonUtil.print("ModifiedNSGAII: file " + fileFullPath + " does not exist!");
}
}
//*************************************************************************************************************
// Distance_to_reference_assignement function
//*************************************************************************************************************
public static double distance_to_reference_assignement(int numWaste,int numObstacles,double[][] chromosomes,int M,int SizeUnion,double[] fmin,double[] fmax,RefPoint R)
{
double x = 0;
for(int j=0;j<SizeUnion;j++)
{
//System.out.println("j = "+j);
double result;
double sum = 0;

for (int i1=0;i1<M;i1++)
{
//System.out.println("M = "+i1);
if(i1 % 2 == 0)
{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.x) / (fmax[i1]-fmin[i1]));
sum= sum +floor(B/7,4);

}else{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.y) / (fmax[i1]-fmin[i1]));
sum = sum + floor(B/7,4);

}
}

result=Math.sqrt(sum);
x=floor(result,4);
chromosomes[j][((numWaste+numObstacles)*2)+7]=x;

}
return x;
}
//===============================================================
public static double floor(double a, int n) {
double p = Math.pow(10.0, n);
return Math.floor((a*p)+0.5) / p;
}
//=========================================================

public static double carre(double x)
{
double y = x * x;
return y;
}

} // NSGA-II

Réponse 3 / 5

choubaka Messages postés 39442 Date d'inscription Statut Modérateur Dernière intervention 2 105

Bonjour

Pas évident de s'y retrouver avec ton code...

Tu devrais peut être effectuer d'abord un peu de refactoring en fractionnant ta "méga" méthode "execute;

Le code sera beaucoup plus clair, plus objet et l'erreur plus facilement repérable.

cordialement

Réponse 4 / 5

arth Messages postés 9374 Date d'inscription Statut Contributeur Dernière intervention 1 293

Le pire c'est que l'erreur donne normalement le numéro de ligne.

Suffirait qu'il nous donne l'erreur complète et la ligne en question, et c'est presque réglé.

asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention

j'arrive a trouver l'erreur :)

Mais le programme se bloque toujours avant de terminer l'exécution :(

arth Messages postés 9374 Date d'inscription Statut Contributeur Dernière intervention 1 293

Ok ça doit être une blague alors :-)

Si tu as trouvé l'erreur, il n'y a donc plus d'erreur dans ce cas.

asmakalboussi Messages postés 45 Date d'inscription Statut Membre Dernière intervention

non c'est pas un blague :)
il ya un souci encore puisque il ya toujours un bloquage lorsque je travaille avec un nombre d'évaluations élevés :/ malheureusement , mon code n'est pas bien structuré et de ça vient la difficulté

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 5 / 5

KX Messages postés 16761 Date d'inscription Statut Modérateur Dernière intervention 3 020

Quand tu fais des boucles comme ça :

for (int i = 0; i<numWaste; i++) { 
    Waste w = tc.getWaste(i);
    decisionVariables.variables_[numObstacles+i].setValue( w.getLocation().getX());
    decisionVariables.variables_[numObstacles+i+mid].setValue( w.getLocation().getY());
}

Il est très difficile de s'y retrouver pour savoir si numObstacles+i et numObstacles+i+mid sont bien entre 0 et variables_.length-1
C'est à ce moment là qu'intervient le débogueur pour identifier les valeurs de chaque composantes au moment de l'exécution foireuse (c'est d'autant plus facile que tu dis savoir où est l'erreur) pour identifier et corriger le problème...

Par exemple, la boucle juste avant celle-ci tu avais une condition supplémentaire : if(numObstacles+numWaste!=mid), on ne sait pas trop ce qu'elle vient faire ici, mais ça ressemble à un traitement d'un cas particulier, peut-être que ce cas particulier devrait aussi être traité sur cette boucle avec une condition similaire : if(numObstacles+mid+numWaste<=decisionVariables.variables_.length)La confiance n'exclut pas le contrôle

Discussions similaires

Erreur 3005 sur France TV

Code erreur 3000

Problème streaming France 2

Panne T32 sur telecommande Orange

impossible lire vidéos france 2

Votre réponse

Discussions similaires