Esempio n. 1
0
 int IComparer.Compare (object x, object y)
 {
   if (x == null)
     return 1; else if (y == null)
     return -1;
   
   int dominate1;
   // dominate1 indicates if some objective of solution1 
   // dominates the same objective in solution2. dominate2
   int dominate2;
   // is the complementary of dominate1.
   
   dominate1 = 0;
   dominate2 = 0;
   
   Solution solution1 = (Solution)x;
   Solution solution2 = (Solution)y;
   
   int flag;
   double value1, value2;
   for (int i = 0; i < solution1.numberOfObjectives_; i++) {
     IComparer objectiveComparator = new ObjectiveComparator (i);
     flag = objectiveComparator.Compare (solution1, solution2);
     value1 = solution1.objective_[i];
     value2 = solution2.objective_[i];
     
     if (value1 < value2) {
       flag = -1;
     } else if (value1 > value2) {
       flag = 1;
     } else {
       flag = 0;
     }
     
     if (flag == -1) {
       dominate1 = 1;
     }
     
     if (flag == 1) {
       dominate2 = 1;
     }
   }
   
   if (dominate1 == 0 && dominate2 == 0) {
     return 0;
     //No one dominate the other
   }
   
   if (dominate1 == 1) {
     return -1;
     // solution1 dominate
   } else if (dominate2 == 1) {
     return 1;
     // solution2 dominate
   }
   return 2;
 }
Esempio n. 2
0
        // The solution set to be ranked

/*
 * public double [][] distanceMatrix(SolutionSet solutionSet) {
 *  Solution solutionI, solutionJ;
 *
 *  //The matrix of distances
 *  double [][] distance = new double [solutionSet.size()][solutionSet.size()];
 *  //-> Calculate the distances
 *  for (int i = 0; i < solutionSet.size(); i++){
 *    distance[i][i] = 0.0;
 *    solutionI = solutionSet.get(i);
 *    for (int j = i + 1; j < solutionSet.size(); j++){
 *      solutionJ = solutionSet.get(j);
 *      distance[i][j] = this.distanceBetweenObjectives(solutionI,solutionJ);
 *      distance[j][i] = distance[i][j];
 *    } // for
 *  } // for
 *
 *  //->Return the matrix of distances
 *  return distance;
 * } // distanceMatrix
 *
 * public double distanceToSolutionSetInObjectiveSpace(Solution    solution,
 *                                    SolutionSet solutionSet) throws JMException{
 *  //At start point the distance is the max
 *  double distance = Double.MAX_VALUE;
 *
 *  // found the min distance respect to population
 *  for (int i = 0; i < solutionSet.size();i++){
 *    double aux = this.distanceBetweenObjectives(solution,solutionSet.get(i));
 *    if (aux < distance)
 *      distance = aux;
 *  } // for
 *
 *  //->Return the best distance
 *  return distance;
 * } // distanceToSolutionSetinObjectiveSpace
 *
 * public double distanceToSolutionSetInSolutionSpace(Solution    solution,
 *                                    SolutionSet solutionSet) throws JMException{
 *   //At start point the distance is the max
 *   double distance = Double.MAX_VALUE;
 *
 *   // found the min distance respect to population
 *   for (int i = 0; i < solutionSet.size();i++){
 *     double aux = this.distanceBetweenSolutions(solution,solutionSet.get(i));
 *     if (aux < distance)
 *       distance = aux;
 *   } // for
 *
 *   //->Return the best distance
 *   return distance;
 * } // distanceToSolutionSetInSolutionSpace
 *
 *
 * public double distanceBetweenSolutions(Solution solutionI, Solution solutionJ)
 * throws JMException{
 *  //->Obtain his decision variables
 *  Variable[] decisionVariableI = solutionI.getDecisionVariables();
 *  Variable[] decisionVariableJ = solutionJ.getDecisionVariables();
 *
 *  double diff;    //Auxiliar var
 *  double distance = 0.0;
 *  //-> Calculate the Euclidean distance
 *  for (int i = 0; i < decisionVariableI.length; i++){
 *    diff = decisionVariableI[i].getValue() -
 *           decisionVariableJ[i].getValue();
 *    distance += Math.pow(diff,2.0);
 *  } // for
 *
 *  //-> Return the euclidean distance
 *  return Math.sqrt(distance);
 * } // distanceBetweenSolutions
 *
 *
 * public double distanceBetweenObjectives(Solution solutionI, Solution solutionJ){
 *  double diff;    //Auxiliar var
 *  double distance = 0.0;
 *  //-> Calculate the euclidean distance
 *  for (int nObj = 0; nObj < solutionI.numberOfObjectives();nObj++){
 *    diff = solutionI.getObjective(nObj) - solutionJ.getObjective(nObj);
 *    distance += Math.pow(diff,2.0);
 *  } // for
 *
 *  //Return the euclidean distance
 *  return Math.sqrt(distance);
 * } // distanceBetweenObjectives.
 *
 */
        internal static void crowdingDistanceAssignment(SolutionSet solutionSet, int nObjs)
        {
            // <pex>
            if (solutionSet == (SolutionSet)null)
            {
                throw new ArgumentNullException("solutionSet");
            }
            if (solutionSet[0] == (Solution)null)
            {
                throw new ArgumentNullException("solutionSet");
            }
            // </pex>
            int size = solutionSet.size();

            if (size == 0)
            {
                return;
            }

            if (size == 1)
            {
                solutionSet[0].crowdingDistance_ = Double.MaxValue;
                //solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
                return;
            } // if

            if (size == 2)
            {
                solutionSet[0].crowdingDistance_ = Double.MaxValue;
                solutionSet[1].crowdingDistance_ = Double.MaxValue;
                return;
            } // if

            //Use a new SolutionSet to evite alter original solutionSet
            SolutionSet front = new SolutionSet(size);

            for (int i = 0; i < size; i++)
            {
                front.add(solutionSet[i]);
            }

            for (int i = 0; i < size; i++)
            {
                front[i].crowdingDistance_ = 0.0;
            }

            double objetiveMaxn;
            double objetiveMinn;
            double distance;

            for (int i = 0; i < nObjs; i++)
            {
                // Sort the population by Obj n
                IComparer comp = new ObjectiveComparator(i);
                front.solutionList_.Sort(comp.Compare);
                //front.sort(new ObjectiveComparator(i));

                objetiveMinn = front[0].objective_[i];
                objetiveMaxn = front[front.size() - 1].objective_[i];

                //Set de crowding distance
                front[0].crowdingDistance_        = Double.MaxValue;
                front[size - 1].crowdingDistance_ = Double.MaxValue;

                for (int j = 1; j < size - 1; j++)
                {
                    distance  = front[j + 1].objective_[i] - front[j - 1].objective_[i];
                    distance  = distance / (objetiveMaxn - objetiveMinn);
                    distance += front[j].crowdingDistance_;
                    front[j].crowdingDistance_ = distance;
                } // for
            }     // for
        }         // crowdingDistanceAssing
Esempio n. 3
0
    // The solution set to be ranked

/*
  public double [][] distanceMatrix(SolutionSet solutionSet) {
    Solution solutionI, solutionJ;

    //The matrix of distances
    double [][] distance = new double [solutionSet.size()][solutionSet.size()];        
    //-> Calculate the distances
    for (int i = 0; i < solutionSet.size(); i++){
      distance[i][i] = 0.0;
      solutionI = solutionSet.get(i);
      for (int j = i + 1; j < solutionSet.size(); j++){
        solutionJ = solutionSet.get(j);
        distance[i][j] = this.distanceBetweenObjectives(solutionI,solutionJ);                
        distance[j][i] = distance[i][j];            
      } // for
    } // for        
    
    //->Return the matrix of distances
    return distance;
  } // distanceMatrix
    
  public double distanceToSolutionSetInObjectiveSpace(Solution    solution,
                                      SolutionSet solutionSet) throws JMException{
    //At start point the distance is the max
    double distance = Double.MAX_VALUE;    
        
    // found the min distance respect to population
    for (int i = 0; i < solutionSet.size();i++){            
      double aux = this.distanceBetweenObjectives(solution,solutionSet.get(i));
      if (aux < distance)
        distance = aux;
    } // for
    
    //->Return the best distance
    return distance;
  } // distanceToSolutionSetinObjectiveSpace
    
   public double distanceToSolutionSetInSolutionSpace(Solution    solution,
                                      SolutionSet solutionSet) throws JMException{
     //At start point the distance is the max
     double distance = Double.MAX_VALUE;    
         
     // found the min distance respect to population
     for (int i = 0; i < solutionSet.size();i++){            
       double aux = this.distanceBetweenSolutions(solution,solutionSet.get(i));
       if (aux < distance)
         distance = aux;
     } // for
     
     //->Return the best distance
     return distance;
   } // distanceToSolutionSetInSolutionSpace
    

  public double distanceBetweenSolutions(Solution solutionI, Solution solutionJ) 
  throws JMException{                
    //->Obtain his decision variables
    Variable[] decisionVariableI = solutionI.getDecisionVariables();
    Variable[] decisionVariableJ = solutionJ.getDecisionVariables();    
    
    double diff;    //Auxiliar var
    double distance = 0.0;
    //-> Calculate the Euclidean distance
    for (int i = 0; i < decisionVariableI.length; i++){
      diff = decisionVariableI[i].getValue() -
             decisionVariableJ[i].getValue();
      distance += Math.pow(diff,2.0);
    } // for    
        
    //-> Return the euclidean distance
    return Math.sqrt(distance);
  } // distanceBetweenSolutions
    

  public double distanceBetweenObjectives(Solution solutionI, Solution solutionJ){                
    double diff;    //Auxiliar var
    double distance = 0.0;
    //-> Calculate the euclidean distance
    for (int nObj = 0; nObj < solutionI.numberOfObjectives();nObj++){
      diff = solutionI.getObjective(nObj) - solutionJ.getObjective(nObj);
      distance += Math.pow(diff,2.0);           
    } // for   
        
    //Return the euclidean distance
    return Math.sqrt(distance);
  } // distanceBetweenObjectives.
           
     */
  internal static void crowdingDistanceAssignment (SolutionSet solutionSet, int nObjs)
  {
    // <pex>
    if (solutionSet == (SolutionSet)null)
      throw new ArgumentNullException("solutionSet");
    if (solutionSet[0] == (Solution)null)
      throw new ArgumentNullException("solutionSet");
    // </pex>
    int size = solutionSet.size ();
    
    if (size == 0)
      return;
    
    if (size == 1) {
      solutionSet[0].crowdingDistance_ = Double.MaxValue ;
      //solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
      return;
    } // if
        
    if (size == 2) {
      solutionSet[0].crowdingDistance_ = Double.MaxValue;
      solutionSet[1].crowdingDistance_ = Double.MaxValue;
      return;
    } // if       
        
    //Use a new SolutionSet to evite alter original solutionSet
    SolutionSet front = new SolutionSet(size);
    for (int i = 0; i < size; i++){
      front.add(solutionSet[i]);
    }
        
    for (int i = 0; i < size; i++)
      front[i].crowdingDistance_ = 0.0 ;
        
    double objetiveMaxn;
    double objetiveMinn;
    double distance;
                
    for (int i = 0; i<nObjs; i++) {          
      // Sort the population by Obj n
      IComparer comp = new ObjectiveComparator(i) ;
      front.solutionList_.Sort(comp.Compare) ;
      //front.sort(new ObjectiveComparator(i));

        objetiveMinn = front[0].objective_[i] ;
      objetiveMaxn = front[front.size()-1].objective_[i] ;
      
      //Set de crowding distance            
      front[0].crowdingDistance_ = Double.MaxValue ;
      front[size -1].crowdingDistance_ = Double.MaxValue ;
      
      for (int j = 1; j < size-1; j++) {
        distance = front[j+1].objective_[i] - front[j-1].objective_[i];
        distance = distance / (objetiveMaxn - objetiveMinn);        
        distance += front[j].crowdingDistance_ ;
        front[j].crowdingDistance_ = distance;
      } // for
    } // for        
  } // crowdingDistanceAssing
Esempio n. 4
0
        int IComparer.Compare(object x, object y)
        {
            if (x == null)
            {
                return(1);
            }
            else if (y == null)
            {
                return(-1);
            }

            int dominate1;
            // dominate1 indicates if some objective of solution1
            // dominates the same objective in solution2. dominate2
            int dominate2;

            // is the complementary of dominate1.

            dominate1 = 0;
            dominate2 = 0;

            Solution solution1 = (Solution)x;
            Solution solution2 = (Solution)y;

            int    flag;
            double value1, value2;

            for (int i = 0; i < solution1.numberOfObjectives_; i++)
            {
                IComparer objectiveComparator = new ObjectiveComparator(i);
                flag   = objectiveComparator.Compare(solution1, solution2);
                value1 = solution1.objective_[i];
                value2 = solution2.objective_[i];

                if (value1 < value2)
                {
                    flag = -1;
                }
                else if (value1 > value2)
                {
                    flag = 1;
                }
                else
                {
                    flag = 0;
                }

                if (flag == -1)
                {
                    dominate1 = 1;
                }

                if (flag == 1)
                {
                    dominate2 = 1;
                }
            }

            if (dominate1 == 0 && dominate2 == 0)
            {
                return(0);
                //No one dominate the other
            }

            if (dominate1 == 1)
            {
                return(-1);
                // solution1 dominate
            }
            else if (dominate2 == 1)
            {
                return(1);
                // solution2 dominate
            }
            return(2);
        }