Erreur introuvable :/

Résolu/Fermé

asmakalboussi Messages postés 45 Date d'inscription dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012 - 24 oct. 2012 à 02:39
asmakalboussi Messages postés 45 Date d'inscription dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012 - 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 :/
Erreur 0x80070643 - Guide
Erreur 38 free ✓ - Forum Mobile
Le chemin d'accès spécifié est introuvable ✓ - Forum Téléchargement
Iptv erreur de lecture - Forum TV & Vidéo
Serveur introuvable ✓ - Forum Réseaux sociaux

5 réponses

Réponse 1 / 5

L0ci Messages postés 110 Date d'inscription mardi 17 avril 2012 Statut Membre Dernière intervention 9 janvier 2013 30
Modifié par L0ci le 24/10/2012 à 08:56

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 dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012
24 oct. 2012 à 12:51

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 mardi 17 avril 2012 Statut Membre Dernière intervention 9 janvier 2013 30
24 oct. 2012 à 15:01

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 dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012
24 oct. 2012 à 12:54

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 39375 Date d'inscription jeudi 4 avril 2002 Statut Modérateur Dernière intervention 14 avril 2024 2 100
24 oct. 2012 à 12:57

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 mardi 27 septembre 2005 Statut Contributeur Dernière intervention 16 décembre 2016 1 291
24 oct. 2012 à 13:20

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 dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012
24 oct. 2012 à 14:47

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 mardi 27 septembre 2005 Statut Contributeur Dernière intervention 16 décembre 2016 1 291
24 oct. 2012 à 18:50

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 dimanche 19 août 2012 Statut Membre Dernière intervention 6 décembre 2012
24 oct. 2012 à 18:56

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 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
Modifié par KX le 24/10/2012 à 15:29

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

Python introuvable

erreur McUICnt.exe

Instagram "Désolé, une erreur s'est produite"

Point d'entrée introuvable

Erreur vidéo inconnue sur le Freebox Player

Discussions similaires

Newsletters